Most Frequently asked python-3.x Interview Questions (2024)

Hirely

at 27 Dec, 2024

Question: What is the difference between Python 2.x and Python 3.x?

Answer:

Python 2.x and Python 3.x are two major versions of the Python programming language. Python 3.x was released to fix various design flaws and provide better support for modern programming practices, but this led to backward incompatibility with Python 2.x. Below are the key differences between Python 2.x and Python 3.x:

1. Print Statement vs. Print Function

Python 2.x: print is treated as a statement.
```
print "Hello, World!"
```
Python 3.x: print is treated as a function and requires parentheses.
```
print("Hello, World!")
```

2. Integer Division

Python 2.x: Division of integers results in an integer (floor division) when both operands are integers.
```
3 / 2    # Output: 1
```
To get a float result, you would need to explicitly convert one of the operands to a float.
```
3 / float(2)    # Output: 1.5
```
Python 3.x: Division of integers results in a float by default.
```
3 / 2    # Output: 1.5
```
If you want integer division (floor division), use the // operator.
```
3 // 2    # Output: 1
```

3. Unicode Handling

Python 2.x: Strings are treated as ASCII by default unless specified as Unicode with a u prefix.
```
s = "hello"      # ASCII string
u = u"hello"     # Unicode string
```
Python 3.x: Strings are treated as Unicode by default, and byte data is handled separately with a b prefix for byte strings.
```
s = "hello"      # Unicode string
b = b"hello"     # Byte string
```

4. Iterators and Generators

Python 2.x: Functions like range(), map(), and filter() return lists.
```
range(5)    # Output: [0, 1, 2, 3, 4]
```
Python 3.x: These functions return iterators, which are more memory efficient, especially for large datasets.
```
range(5)    # Output: range(0, 5) (an iterator object)
```
To get a list in Python 3.x, you can explicitly convert the iterator into a list:
```
list(range(5))    # Output: [0, 1, 2, 3, 4]
```

5. Exception Handling Syntax

Python 2.x: The except clause uses as or a comma.

try:
    # some code
except SomeError, e:
    # handle exception

Python 3.x: The except clause always uses as to bind the exception to a variable.

try:
    # some code
except SomeError as e:
    # handle exception

6. Input Handling

Python 2.x: The input() function evaluates the user input as Python code, and raw_input() is used to get a string input.

x = raw_input("Enter something: ")  # String input
x = input("Enter a number: ")  # Evaluates as Python code

Python 3.x: The input() function returns string input, and raw_input() has been removed.
```
x = input("Enter something: ")  # Always returns a string
```

7. Standard Library Changes

Python 2.x: Many modules and functions in the standard library have different names and may not follow modern practices. For example, urllib and urllib2 were separate in Python 2.x.
Python 3.x: The standard library was reorganized and many modules were renamed or consolidated. For example, urllib in Python 3.x is more consistent, and urllib2 was merged into urllib.

8. Function Annotations

Python 2.x: Function annotations are not supported (except for some third-party libraries).
Python 3.x: Function annotations are supported and can be used to specify the type of parameters and return types.
```
def greet(name: str) -> str:
    return "Hello " + name
```

9. Libraries and Third-Party Support

Python 2.x: As Python 2.x reached its end of life (EOL) on January 1, 2020, many third-party libraries have stopped supporting it, and new libraries are often built exclusively for Python 3.
Python 3.x: Python 3 is actively maintained and supported by the community. It is the recommended version for all new projects and for those migrating from Python 2.x.

10. Performance Improvements

Python 3.x has made numerous performance improvements over Python 2.x, including better memory handling, optimization of various functions, and enhancements to the garbage collection process. For many use cases, Python 3.x is faster than Python 2.x.

11. End of Life (EOL)

Python 2.x: Python 2 reached its official end of life (EOL) on January 1, 2020. This means it no longer receives updates, including security fixes, from the Python Software Foundation.
Python 3.x: Python 3.x is the future of the language and continues to receive new features, performance improvements, and security updates.

Summary of Key Differences:

Feature	Python 2.x	Python 3.x
Print	`print` statement	`print()` function
Integer Division	Integer division results in an integer	Integer division results in a float
Unicode Strings	ASCII by default, use `u` for Unicode	Unicode by default
String Handling	`input()` evaluates input	`input()` returns string
Iterators	Returns list	Returns iterator
Exception Syntax	`except Exception, e:`	`except Exception as e:`
Standard Library	Different module names	Reorganized and renamed modules
Function Annotations	Not supported	Supported
End of Life	January 1, 2020 (no more support)	Actively supported

Conclusion:

Python 3.x introduced many improvements and fixes over Python 2.x, making it the preferred choice for new projects. However, due to the backward incompatibility, migrating from Python 2.x to Python 3.x can require significant changes in code. Python 2.x reached its end of life in 2020, so it is advisable to switch to Python 3 for all new development and maintenance of existing projects.

Question: What are Python decorators?

Answer:

In Python, decorators are a way to modify or extend the behavior of a function or method without changing its source code. A decorator is essentially a function that wraps another function (or method), and allows additional functionality to be added to it before or after its execution.

Decorators are widely used in Python for various purposes, such as logging, authentication, authorization, caching, etc.

How Do Python Decorators Work?

A decorator is a higher-order function that takes a function as input and returns a new function that adds some kind of functionality to the original function.

Basic Syntax of a Decorator:

def decorator_function(original_function):
    def wrapper_function():
        # Code to execute before calling the original function
        print("Wrapper executed this before {}".format(original_function.__name__))
        
        # Call the original function
        return original_function()
    
    return wrapper_function

To apply this decorator to a function, you use the @decorator_name syntax above the function definition.

Example of a Simple Decorator:

def decorator_function(original_function):
    def wrapper_function():
        print("Wrapper executed before {}".format(original_function.__name__))
        return original_function()
    return wrapper_function

# Using the decorator
@decorator_function
def say_hello():
    print("Hello!")

say_hello()

Output:

Wrapper executed before say_hello
Hello!

In this example, @decorator_function is applied to the say_hello function. When say_hello() is called, the wrapper_function is executed first, and then it calls the original say_hello function.

Components of a Decorator:

Outer Function: This is the decorator function that takes a function as input.
Inner Function: This function wraps around the original function and can modify or extend its behavior.
Returning the Inner Function: The decorator returns the inner function, which will be used in place of the original function.

Example with Arguments:

If the decorated function has parameters, the decorator should pass those parameters to the original function as well. This can be done using *args and **kwargs to handle any number of positional and keyword arguments.

def decorator_function(original_function):
    def wrapper_function(*args, **kwargs):
        print("Wrapper executed before {}".format(original_function.__name__))
        return original_function(*args, **kwargs)
    return wrapper_function

@decorator_function
def say_hello(name):
    print("Hello, {}!".format(name))

say_hello("Alice")

Output:

Wrapper executed before say_hello
Hello, Alice!

In this example, the decorator function now accepts any number of arguments (*args and **kwargs) and forwards them to the say_hello function.

Using Built-in Decorators:

Python has several built-in decorators that are commonly used, such as @staticmethod, @classmethod, and @property.

@staticmethod:

It is used to define a method that doesn’t depend on class instance data.

class MyClass:
    @staticmethod
    def say_hello():
        print("Hello from static method!")

@classmethod:
- It is used to define a method that operates on the class, not the instance. It takes the class as its first argument (cls) instead of the instance (self).
```
class MyClass:
    @classmethod
    def greet(cls):
        print("Hello from class method!")
```

@property:

It allows you to define a method as an attribute, so that it can be accessed like an attribute but executed as a method.

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @property
    def area(self):
        return 3.1416 * self._radius * self._radius

Chaining Decorators:

You can apply multiple decorators to a single function by stacking them, with the bottom-most decorator applied first.

def decorator_one(func):
    def wrapper():
        print("Decorator One")
        func()
    return wrapper

def decorator_two(func):
    def wrapper():
        print("Decorator Two")
        func()
    return wrapper

@decorator_one
@decorator_two
def say_hello():
    print("Hello!")

say_hello()

Output:

Decorator One
Decorator Two
Hello!

In this case, say_hello() is first passed through decorator_two, then the result of that is passed to decorator_one.

Practical Use Cases for Decorators:

Logging:

You can use decorators to log function calls, execution times, or results.

def log_function_call(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function {func.__name__} with arguments {args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

@log_function_call
def add(a, b):
    return a + b

Authorization:

You can use decorators to check if the user has the proper permissions before running a function.

def check_permissions(func):
    def wrapper(*args, **kwargs):
        if not has_permission():
            raise PermissionError("You don't have permission to perform this action")
        return func(*args, **kwargs)
    return wrapper

Caching:

You can cache results of expensive function calls using decorators, which can help improve performance.

def cache_results(func):
    cache = {}
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

Summary:

Python decorators are a powerful feature that allows you to add functionality to functions or methods without modifying their actual code.
They work by defining a function that takes another function as input and returns a new function (the wrapped function).
Decorators are often used for logging, access control, memoization (caching), and modifying or enhancing functions in a modular way.
Decorators are a great tool for adhering to the DRY principle (Don’t Repeat Yourself), as they allow you to apply reusable behavior to multiple functions.

Question: What is the difference between a shallow copy and a deep copy in Python?

Answer:

In Python, shallow copy and deep copy refer to how objects are copied, particularly when those objects contain other nested objects (e.g., lists of lists, dictionaries with lists as values, etc.).

1. Shallow Copy

A shallow copy creates a new object, but it does not create copies of nested objects inside the original object. Instead, it simply references the original nested objects. Therefore, the shallow copy will have a new top-level container, but the nested objects will still be shared with the original object.

Key Points:

The top-level container is copied.
The nested objects (inside the container) are not copied, they are just referenced.
Modifying the nested objects in the shallow copy will affect the original object (and vice versa) because they both refer to the same nested objects.

Example of Shallow Copy:

import copy

# Original object
original_list = [[1, 2, 3], [4, 5, 6]]

# Shallow copy
shallow_copy = copy.copy(original_list)

# Modify a nested element
shallow_copy[0][0] = 99

print("Original List:", original_list)
print("Shallow Copy:", shallow_copy)

Output:

Original List: [[99, 2, 3], [4, 5, 6]]
Shallow Copy: [[99, 2, 3], [4, 5, 6]]

Explanation: After modifying shallow_copy[0][0], the original_list[0][0] was also modified because both the original list and the shallow copy reference the same nested list [1, 2, 3].

2. Deep Copy

A deep copy creates a completely new object and also recursively copies all the nested objects inside the original object. As a result, the deep copy is fully independent of the original object. Changes made to the deep copy do not affect the original object, and vice versa.

Key Points:

The top-level container is copied.
Nested objects are recursively copied, meaning the deep copy creates a new independent copy of all nested objects.
Modifying any part of the deep copy will not affect the original object.

Example of Deep Copy:

import copy

# Original object
original_list = [[1, 2, 3], [4, 5, 6]]

# Deep copy
deep_copy = copy.deepcopy(original_list)

# Modify a nested element
deep_copy[0][0] = 99

print("Original List:", original_list)
print("Deep Copy:", deep_copy)

Output:

Original List: [[1, 2, 3], [4, 5, 6]]
Deep Copy: [[99, 2, 3], [4, 5, 6]]

Explanation: After modifying deep_copy[0][0], the original_list remains unchanged because the deep copy created an independent copy of the entire object structure.

Summary of Differences:

Feature	Shallow Copy	Deep Copy
Top-level object	Copied to a new object.	Copied to a new object.
Nested objects	Referenced (not copied).	Copied recursively (deeply).
Effect of modification	Modifying nested objects affects both the original and the copy.	Modifying nested objects only affects the copy.
Method of creation	`copy.copy()`	`copy.deepcopy()`

When to Use:

Shallow Copy: Useful when you want to create a copy of the outer object but are okay with sharing the inner objects (i.e., nested objects) between the original and the copy. This is more memory efficient.
Deep Copy: Necessary when you need an independent copy of an object, including all nested objects, and you want changes to the copy to not affect the original object. This is typically used when the object contains complex nested structures (e.g., lists of dictionaries or lists of lists).

Question: What is the self keyword in Python?

Answer:

In Python, self is a reference to the current instance of the class. It is used in instance methods within a class to refer to the object that is calling the method. It is essentially a way for an object to access its own attributes and methods.

self is not a reserved keyword in Python, but it is a strong convention that is universally used. You can technically use any other name instead of self, but doing so would break standard Python conventions and make the code harder to read and understand for other developers.

Key Points:

Refers to the Current Object: The self parameter in instance methods refers to the specific instance of the class on which the method is being called. This allows you to access the object’s attributes and methods from within the class.
Used to Access Instance Variables and Methods: You use self to reference attributes or call other methods of the current object within the class.
Must Be the First Parameter: In instance methods, self must always be the first parameter, even though it’s not passed explicitly when calling the method. Python implicitly passes the instance as the first argument when the method is invoked.

Example of `self` in Action:

class Dog:
    # Constructor method to initialize the object
    def __init__(self, name, age):
        self.name = name  # self.name refers to the instance variable 'name'
        self.age = age    # self.age refers to the instance variable 'age'

    # Instance method that uses self
    def bark(self):
        print(f"{self.name} says Woof!")

    def display_age(self):
        print(f"{self.name} is {self.age} years old.")

# Create an instance of the Dog class
my_dog = Dog("Buddy", 3)

# Accessing instance methods and attributes using self
my_dog.bark()            # Buddy says Woof!
my_dog.display_age()     # Buddy is 3 years old.

In the code above:

The __init__ method uses self to assign the name and age attributes to the instance of the Dog class.
The bark and display_age methods also use self to access these instance attributes and methods.
When calling my_dog.bark() or my_dog.display_age(), Python implicitly passes my_dog as the self parameter to these methods.

How `self` Works in Method Calls:

When you call an instance method like my_dog.bark(), Python implicitly sends the my_dog object as the first argument to the bark() method, i.e., bark(self) becomes bark(my_dog). This allows the method to access and modify the my_dog object’s attributes and behavior.

Why `self` is Important:

Distinguishing Instance Variables: It allows you to differentiate between instance variables and local variables or parameters inside the methods. For example, when you define self.name, you’re telling Python that this is an instance variable, not a local variable.
Accessing Instance Methods: self is used to call other instance methods from within a class. Without self, you would not be able to refer to the instance of the class.

Common Misunderstandings:

self is not a keyword: You can technically replace self with another name, but it’s a convention that should not be altered. It’s part of the Python style guide (PEP 8) to use self consistently.
self is not automatically passed when calling a method: Although you must include self as the first parameter in the method definition, when calling the method (e.g., my_dog.bark()), you don’t pass self explicitly. Python automatically passes the instance (in this case, my_dog) as self.

Example with Multiple Instances:

class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year

    def get_info(self):
        return f"{self.year} {self.brand} {self.model}"

# Create multiple instances of the Car class
car1 = Car("Toyota", "Corolla", 2020)
car2 = Car("Honda", "Civic", 2021)

# Access instance-specific information
print(car1.get_info())  # 2020 Toyota Corolla
print(car2.get_info())  # 2021 Honda Civic

In this example:

self ensures that each car object (car1 and car2) has its own attributes (brand, model, year) and the correct information is returned when get_info() is called for each instance.

Summary:

self is a reference to the current instance of a class in Python.
It is used to access instance variables and methods within a class.
self must always be the first parameter in an instance method, but you don’t explicitly pass it when calling the method—Python does it automatically.
self is crucial for object-oriented programming in Python, allowing you to write code that works with individual instances of a class.

Question: What is the difference between `@staticmethod` and `@classmethod` in Python?

Answer:

In Python, both @staticmethod and @classmethod are used to define methods that are not bound to a specific instance of a class, but they differ in how they interact with the class and its instances.

1. `@staticmethod` (Static Method)

A static method is a method that belongs to the class itself, rather than an instance of the class. It does not take self or cls as the first parameter. This means that static methods cannot access or modify the instance (object) or the class itself. They are essentially regular functions that happen to reside inside a class for organizational purposes.

Does not have access to the instance (self) or the class (cls).
Does not modify class state or instance state.
It is used when you need a method that logically belongs to the class but doesn’t need access to class or instance data.

Example of `@staticmethod`:

class Math:
    @staticmethod
    def add(a, b):
        return a + b

# Call the static method without creating an instance
result = Math.add(5, 10)
print(result)  # Output: 15

In this example:

The add() method does not access or modify any class or instance properties. It simply performs an operation and returns a result.

2. `@classmethod` (Class Method)

A class method is a method that is bound to the class rather than an instance of the class. It takes the class itself (cls) as the first parameter, not the instance (self). Class methods can access and modify the class state, but not the instance state. Class methods are typically used for factory methods or methods that affect the class as a whole (rather than individual instances).

Takes cls (the class) as the first parameter (not self).
Can access and modify class state but not instance state.
Can be called on the class itself or on an instance, but they always refer to the class.

Example of `@classmethod`:

class Dog:
    species = "Canis familiaris"  # Class variable

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

    @classmethod
    def get_species(cls):
        return cls.species

# Call the class method on the class itself
print(Dog.get_species())  # Output: Canis familiaris

# Call the class method on an instance
dog = Dog("Buddy", 5)
print(dog.get_species())  # Output: Canis familiaris

In this example:

The get_species() method accesses the class-level variable species using cls.
You can call a class method on both the class itself and on an instance, but it always refers to the class.

Summary of Differences:

Feature	`@staticmethod`	`@classmethod`
First parameter	Does not take `self` or `cls`.	Takes `cls` (the class itself) as the first parameter.
Access to instance	Cannot access instance variables (`self`).	Cannot access instance variables (`self`) directly, but can access class variables.
Access to class	Cannot access class variables (`cls`).	Can access and modify class variables using `cls`.
Use case	When a method doesn’t need to modify the class or instance.	When you need to operate on class-level data or create factory methods.
How to call	Called on the class or an instance, but typically used on the class.	Called on the class, but can also be called on instances (it always refers to the class).

When to Use:

Use @staticmethod: When the method does not need to interact with the class or instance and is just logically part of the class.
Use @classmethod: When the method needs to modify the class state, or when you want to create a method that can work with class-level data or return an instance of the class (e.g., a factory method).

Factory Method Example with `@classmethod`:

A common use of class methods is to implement factory methods, which are methods that return an instance of the class.

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

    @classmethod
    def from_birth_year(cls, name, birth_year):
        age = 2024 - birth_year  # Assume current year is 2024
        return cls(name, age)

# Creating a Person object using the class method
person = Person.from_birth_year("Alice", 1990)
print(person.name)  # Output: Alice
print(person.age)   # Output: 34

Here, the from_birth_year() class method is used to create a new Person object by calculating the age based on the birth year. This is a typical use case for @classmethod to construct objects in different ways.

Question: How does Python handle memory management?

Answer:

Python manages memory automatically using a combination of techniques, including reference counting, garbage collection, and memory pools. Below is an explanation of each of these methods:

1. Reference Counting

Python uses reference counting as one of the main techniques for memory management. Every object in Python has an associated reference count, which tracks the number of references (variables, data structures, etc.) pointing to that object.

When an object is created, its reference count is initialized to 1.
When a new reference to the object is created, the reference count is incremented.
When a reference is deleted or goes out of scope, the reference count is decremented.

Once an object’s reference count reaches zero, meaning there are no references to that object anymore, Python automatically deallocates the memory used by that object. This is called automatic memory deallocation.

Example:

a = [1, 2, 3]  # a references the list [1, 2, 3]
b = a           # b references the same list
del a           # reference count of the list is 1 (still referenced by b)
del b           # reference count drops to 0, and the object is deallocated

In the above example:

The list [1, 2, 3] is initially referenced by a.
When b = a is executed, the reference count of the list increases to 2.
Deleting a reduces the reference count, but the object is still referenced by b.
When b is deleted, the reference count becomes zero, and the object is deallocated.

2. Garbage Collection

Python also includes a garbage collector to manage cyclic references. While reference counting handles most memory deallocation cases, it cannot deal with circular references (e.g., two objects referencing each other). Python’s garbage collector solves this problem.

The garbage collector is a part of the gc module, which is responsible for detecting and cleaning up reference cycles (i.e., groups of objects that reference each other but are not reachable from any external object).

How Garbage Collection Works:

The garbage collector periodically checks for unreachable objects (i.e., objects that are no longer referenced by any part of the program, including circular references).
If such objects are found, the garbage collector deallocates them and frees their memory.
Python’s garbage collector uses a technique called generational garbage collection, which divides objects into three generations based on how long they have been in memory.

Generational Garbage Collection:

Young Generation (Generation 0): Newly created objects.
Middle Generation (Generation 1): Objects that survived one or more garbage collection cycles.
Old Generation (Generation 2): Objects that have survived several cycles and are unlikely to be garbage collected.

This approach optimizes garbage collection by focusing on collecting younger objects, which are more likely to be garbage, and avoiding frequent collection of older, long-lived objects.

Example of Cyclic Garbage Collection:

import gc

class A:
    def __init__(self):
        self.ref = None

# Create two objects that reference each other (cyclic reference)
obj1 = A()
obj2 = A()

obj1.ref = obj2
obj2.ref = obj1

# Delete the objects
del obj1
del obj2

# At this point, the objects are no longer in use, but the reference cycle may still exist.
# We can manually run garbage collection
gc.collect()

In this case:

obj1 and obj2 reference each other, creating a cyclic reference.
Without garbage collection, these objects would remain in memory because of the circular references.
By manually invoking gc.collect(), Python detects and cleans up these unreachable objects.

3. Memory Pools

Python uses memory pools to optimize memory allocation and reduce overhead. Python’s memory management system divides memory into small, fixed-size blocks (or pools), which are used to store objects of similar sizes. This helps avoid fragmentation and speeds up memory allocation and deallocation.

Small Object Allocator: For small objects, Python uses a system called pymalloc, which allocates memory in blocks of predefined sizes (e.g., for small integers or short strings). This system reduces memory overhead and improves performance for allocating small objects.
Large Objects: For larger objects (e.g., large lists, dictionaries), Python falls back on using the operating system’s allocator.

4. The `del` Statement

The del statement in Python removes a reference to an object. This reduces the reference count by 1. When the reference count of an object drops to zero, the object is deallocated. However, del does not immediately free memory; it only removes a reference. The memory is reclaimed later, when Python’s garbage collector runs.

Example of `del`:

a = [1, 2, 3]
del a  # 'a' is deleted, but memory is freed later

In this case, the list [1, 2, 3] is deleted, but its memory is freed by the garbage collector once it detects that there are no references to it.

5. Memory Leaks in Python

While Python has a robust memory management system, memory leaks can still occur, typically due to unintentional references. For example, objects might remain in memory because they are still referenced, even though they are no longer needed. Common causes include:

Holding references in global variables or static data structures.
Circular references that are not properly cleaned up by the garbage collector.

To help detect memory leaks, you can use Python’s gc module to inspect garbage collection activity and monitor memory usage.

6. Tools for Memory Management

Python provides tools to help manage and monitor memory:

gc module: Provides functions for interacting with the garbage collector, manually triggering collection, and debugging memory issues.
sys.getsizeof(): A built-in function to determine the size of an object in memory.
objgraph: A third-party library for generating object reference graphs to help detect memory leaks.

Example of checking memory usage with sys.getsizeof():

import sys

a = [1, 2, 3]
print(sys.getsizeof(a))  # Outputs the memory size of the object `a` in bytes

Summary of Python’s Memory Management:

Reference Counting: Objects are deallocated when their reference count drops to zero.
Garbage Collection: Python’s garbage collector handles circular references and unreferenced objects using generational garbage collection.
Memory Pools: Small objects are allocated in memory pools to reduce fragmentation and improve performance.
del Statement: Used to delete references, which decreases the reference count.
Memory Leaks: Unused objects can still remain in memory due to unintentional references or circular references that the garbage collector may not handle.

Python’s memory management system, combining reference counting, garbage collection, and memory pools, is efficient and mostly transparent to the programmer, allowing Python developers to focus more on logic and less on memory management. However, it is still important to understand how these mechanisms work to avoid memory-related issues like leaks.

Question: What are Python generators and how do they work?

Answer:

Python generators are a powerful feature that allows for lazy evaluation of sequences. They enable you to iterate over potentially large data sets without loading the entire sequence into memory. This is especially useful when dealing with large amounts of data or when you want to implement efficient and memory-conserving algorithms.

Generators are a special type of iterable that generate values one at a time as you loop through them, instead of computing all values upfront and storing them in memory.

How do Python Generators Work?

Python generators use the **yield** keyword to produce a value and temporarily suspend the function’s state, allowing it to resume where it left off. This makes them distinct from regular functions, which return a value using the **return** keyword and exit the function.

1. `yield` Keyword

The yield keyword is used to produce a value from the generator function. When the generator’s function is called, it doesn’t execute immediately. Instead, it returns a generator object, which can be iterated over using a loop or through a function like next().

Each time the yield statement is encountered, the function’s state is saved (including variable values and the current execution point).
The function does not terminate after yield. Instead, it suspends and can be resumed later from the exact point where it left off.

2. Creating a Generator Function

To create a generator, you simply define a function using the yield keyword instead of return. This function will be called a generator function.

Example of a Simple Generator:

def count_up_to(max):
    count = 1
    while count <= max:
        yield count  # Yield is used instead of return
        count += 1

# Create a generator object
counter = count_up_to(5)

# Iterate over the generator using a loop
for num in counter:
    print(num)

Output:

In this example:

The count_up_to() function is a generator function.
It yields the numbers from 1 to the specified max.
The generator is used in a for loop, which automatically handles the iteration.

3. How Generators are Different from Regular Functions

return vs. yield: A regular function uses return to send back a result and terminate. A generator function uses yield to send a result and pause the function’s execution. The function’s state is saved, so it can resume from where it left off.
Memory Efficiency: Generators are lazy — they produce items one at a time, and only when they are needed. Unlike lists or other data structures, a generator does not store all its values in memory at once, making it more memory-efficient for large datasets.

Key Characteristics of Python Generators

Laziness: Generators do not compute their values until they are needed (lazy evaluation). This allows for more memory-efficient handling of large datasets.
State Retention: When a generator yields a value, it retains its state (i.e., the position of execution, local variables, etc.). When the next value is requested (e.g., by next() or a loop), execution resumes from where it last left off.
Iteration: Generators can be iterated over just like lists, tuples, or other iterables. Python’s for loop can automatically handle this, as can the next() function.
Infinite Sequences: Since generators produce values on demand, they can represent infinite sequences. For example, a generator could produce all prime numbers indefinitely, without ever running out of memory.

Example of Using `next()` with a Generator

You can manually advance a generator using the next() function. Each time you call next(), the generator resumes its execution and returns the next value.

def countdown(num):
    while num > 0:
        yield num
        num -= 1

# Create the generator
counter = countdown(5)

# Manually iterate using next()
print(next(counter))  # Output: 5
print(next(counter))  # Output: 4
print(next(counter))  # Output: 3
print(next(counter))  # Output: 2
print(next(counter))  # Output: 1
# next(counter) will raise StopIteration when the generator is exhausted

In this example:

Each call to next(counter) yields the next value from the generator.
Once the generator is exhausted (i.e., there are no more values to yield), a StopIteration exception is raised.

Generator Expressions

In addition to generator functions, you can create generator expressions, which are similar to list comprehensions but use parentheses () instead of square brackets []. They allow you to create a generator in a more concise way.

Example of a Generator Expression:

gen_expr = (x * x for x in range(5))

# Iterate over the generator expression
for num in gen_expr:
    print(num)

Output:

This is equivalent to writing a full generator function, but it’s more compact and works for simple cases where you don’t need complex logic.

Advantages of Generators

Memory Efficiency: Since generators do not store all the values at once, they are very memory efficient, especially for large datasets.
Performance: They can be faster than using lists for large datasets because they generate items on the fly and avoid unnecessary computations or storage.
Infinite Sequences: Generators are well-suited for representing infinite sequences. For example, generating an infinite series of numbers or items can be done with a generator without running into memory issues.
Lazy Evaluation: Because generators are lazy, you can perform computations on-the-fly without needing to calculate everything upfront.

When to Use Generators

When dealing with large datasets: If you have a large collection of items but only need to access them one at a time, generators can help reduce memory usage.
When you need to implement a lazy sequence: Generators are ideal for handling potentially infinite sequences, such as reading large files, generating prime numbers, or implementing streaming algorithms.
When you need to handle expensive computations lazily: If calculating items is expensive, and you only need a few at a time, a generator can produce the results without computing all the values upfront.

Summary:

Generators are functions that use yield to produce a series of values lazily, without creating and storing them in memory.
They allow for efficient iteration over large or infinite data sets.
Python generators use the yield keyword to pause the function’s state and return control to the caller, which can resume the function where it left off.
Memory-efficient and lazy evaluation make generators a great choice for scenarios that involve large data or streaming data.

Question: What is the difference between `is` and `==` in Python?

Answer:

In Python, is and == are both used for comparison, but they serve different purposes:

== (Equality Operator):
- == checks if the values of two objects are equal.
- It compares the data stored in the objects.
- Example:
```
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # Output: True
```
  Here, a == b returns True because the contents of the lists are the same, even though a and b are two different objects in memory.
is (Identity Operator):
- is checks if two variables refer to the same object in memory (i.e., their identity is the same).
- It compares the memory addresses of the objects.
- Example:
```
a = [1, 2, 3]
b = [1, 2, 3]
print(a is b)  # Output: False
```
  In this case, a is b returns False because a and b are two different objects in memory, even though they contain the same data.

Summary:

Use == to check if the values of two objects are equal.
Use is to check if two variables point to the exact same object in memory.

This distinction is important because in some cases (e.g., with immutable types like small integers or strings), Python may reuse objects, making is and == behave similarly. But for most cases, especially with mutable objects like lists or dictionaries, is checks for identity, and == checks for equality in value.

Question: What is the concept of list comprehensions in Python?

Answer:

List comprehensions in Python provide a concise and readable way to create lists. They allow you to generate a new list by applying an expression to each item in an existing iterable (like a list, tuple, or range). The syntax is more compact than traditional loops, making your code cleaner and often more efficient.

Basic Syntax:

[expression for item in iterable]

Where:

expression: The value or operation to apply to each item.
item: The variable representing each element in the iterable.
iterable: The collection or sequence you are looping through.

Example 1: Basic List Comprehension

# Create a list of squares for numbers from 1 to 5
squares = [x**2 for x in range(1, 6)]
print(squares)  # Output: [1, 4, 9, 16, 25]

In this example, the list comprehension [x**2 for x in range(1, 6)] generates the squares of numbers from 1 to 5.

Example 2: List Comprehension with Conditional Logic

You can also add an if condition to filter items while creating the list:

# Create a list of squares for even numbers from 1 to 10
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)  # Output: [4, 16, 36, 64, 100]

Here, the list comprehension includes only the squares of even numbers by using the condition if x % 2 == 0.

Example 3: Nested List Comprehensions

List comprehensions can be nested to work with multidimensional data:

# Create a list of lists (matrix)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Flatten the matrix into a single list
flat = [item for sublist in matrix for item in sublist]
print(flat)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In this example, the list comprehension flattens the 2D list (matrix) into a 1D list.

Advantages of List Comprehensions:

Conciseness: List comprehensions reduce the amount of code needed to generate a list.
Readability: They are more readable than traditional loops, especially for simple operations.
Performance: List comprehensions can be faster than using loops because they are optimized in Python’s bytecode.

Summary:

List comprehensions are a powerful feature in Python that make it easy to create and manipulate lists in a single, readable line of code. They can be used with or without conditions and support nested iterations for complex tasks.

Question: What are Python’s built-in data types?

Answer:

Python provides several built-in data types that allow you to work with different kinds of data. These data types can be broadly classified into several categories:

1. Numeric Types:

int (Integer): Represents whole numbers, both positive and negative, without a fractional part.
```
a = 10
b = -5
```
float (Floating-point number): Represents numbers with a decimal point or numbers in exponential notation.
```
x = 3.14
y = -2.5
```
complex: Represents complex numbers with a real and an imaginary part.
```
z = 3 + 4j
```

2. Sequence Types:

list: A mutable, ordered collection of items, which can be of different types.
```
lst = [1, 2, 3, "hello"]
```
tuple: An immutable, ordered collection of items, which can also contain different types.
```
tpl = (1, 2, 3, "world")
```
range: Represents an immutable sequence of numbers, often used for looping.
```
r = range(5)  # [0, 1, 2, 3, 4]
```

3. Text Type:

str: Represents a sequence of characters (strings). It is immutable.
```
text = "Hello, Python!"
```

4. Mapping Type:

dict (Dictionary): An unordered collection of key-value pairs. Keys are unique, and values can be of any type.
```
d = {"name": "Alice", "age": 25, "city": "New York"}
```

5. Set Types:

set: An unordered collection of unique elements.
```
s = {1, 2, 3, 4}
```
frozenset: An immutable version of a set. Once created, its elements cannot be changed.
```
fs = frozenset([1, 2, 3])
```

6. Boolean Type:

bool: Represents truth values. It has two possible values: True and False.
```
flag = True
```

7. Binary Types:

bytes: Immutable sequence of bytes, often used for binary data.
```
b = b"hello"
```
bytearray: A mutable sequence of bytes.
```
ba = bytearray([65, 66, 67])
```
memoryview: Allows access to the internal data of an object without copying.
```
mv = memoryview(b"hello")
```

8. None Type:

None: Represents the absence of a value or a null value.
```
x = None
```

Summary:

Here’s a quick summary of the main built-in data types in Python:

Numeric Types: int, float, complex
Sequence Types: list, tuple, range
Text Type: str
Mapping Type: dict
Set Types: set, frozenset
Boolean Type: bool
Binary Types: bytes, bytearray, memoryview
None Type: None

These data types provide the foundation for handling various types of data in Python, and you can manipulate them using built-in methods and operators.

Question: What is the purpose of the `with` statement in Python?

Answer:

The with statement in Python is used to simplify exception handling and ensure that certain resources are properly managed, such as files, network connections, or database connections. It is often used in conjunction with context managers, which are objects that define the behavior of the with statement.

Key Benefits:

Automatic Resource Management: The with statement ensures that resources are acquired and released properly, even if an exception occurs within the block.
Cleaner Code: It simplifies code, making it more readable by handling setup and cleanup operations automatically.
Exception Safety: The with statement guarantees that resources are cleaned up even if an error happens inside the block.

Syntax:

with expression as variable:
    # Code block that works with the resource

expression: This is usually a context manager that provides a __enter__() method for acquiring the resource and a __exit__() method for releasing it.
variable: An optional variable to store the resource managed by the context manager (e.g., a file handle).

Example 1: File Handling

One of the most common use cases of the with statement is working with files:

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Here’s how it works:

The open("example.txt", "r") expression returns a file object that is a context manager.
The __enter__() method is called to open the file, and the file object is assigned to the variable file.
After the block is executed (whether successfully or with an exception), the __exit__() method is called to automatically close the file.

Without the with statement, you would need to manually close the file:

file = open("example.txt", "r")
content = file.read()
print(content)
file.close()  # You have to remember to do this

Example 2: Custom Context Manager

You can define your own context manager using a class with __enter__() and __exit__() methods:

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting the context")
        # Handle exception if needed
        if exc_type is not None:
            print(f"An exception occurred: {exc_val}")
        return True  # Suppress exception (optional)

with MyContextManager():
    print("Inside the context")
    # Uncomment the next line to see exception handling in action
    # raise ValueError("Something went wrong")

Output:

Entering the context
Inside the context
Exiting the context

If an exception were raised inside the with block, the __exit__() method would handle it, and the program would continue without crashing, depending on the return value of __exit__().

Summary:

The with statement is used to ensure that resources are properly acquired and released.
It simplifies resource management by automatically handling setup and cleanup operations.
It makes the code cleaner, more readable, and less error-prone by managing exceptions and ensuring resources (like files, locks, or network connections) are always released.

Question: How do you handle exceptions in Python?

Answer:

In Python, exceptions are events that disrupt the normal flow of a program. When something goes wrong (like dividing by zero, accessing a non-existent file, or using an invalid type), Python raises an exception. You can handle exceptions using the try, except, else, and finally blocks.

Basic Structure of Exception Handling:

try:
    # Code that might raise an exception
    risky_code()
except SomeException as e:
    # Code that runs if an exception occurs
    handle_exception(e)
else:
    # Code that runs if no exception occurs
    success_code()
finally:
    # Code that runs no matter what (exception or not)
    cleanup_code()

Explanation of Each Block:

try Block:
- This is where you put the code that might raise an exception. If an exception occurs, Python will immediately jump to the except block.
except Block:
- This block catches and handles the exception. You can specify which type of exception to handle (e.g., ZeroDivisionError, FileNotFoundError), or use a generic Exception to catch any kind of exception.
- You can also access the exception instance using the as keyword to retrieve details about the exception.
Example:
```
try:
    result = 10 / 0  # Raises ZeroDivisionError
except ZeroDivisionError as e:
    print(f"Error: {e}")  # Output: Error: division by zero
```

else Block (Optional):

If no exceptions are raised in the try block, the else block is executed. This is useful when you want to run code that should only happen if the try block succeeds.

Example:

try:
    value = 10 / 2  # No exception occurs
except ZeroDivisionError as e:
    print("Division by zero!")
else:
    print("Division successful, result is:", value)  # Output: Division successful, result is: 5.0

finally Block (Optional):
- This block is executed no matter what—whether an exception was raised or not. It’s commonly used for cleanup operations, like closing files, releasing resources, or restoring states.
Example:
```
try:
    f = open("example.txt", "r")
    content = f.read()
except FileNotFoundError as e:
    print(f"Error: {e}")
finally:
    f.close()  # Ensures the file is always closed
```

Catching Multiple Exceptions:

You can handle multiple types of exceptions in different ways:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ValueError as ve:
    print("Invalid input! Please enter a number.")
except ZeroDivisionError as ze:
    print("Cannot divide by zero!")

Catching All Exceptions:

To catch any exception, you can use a generic except clause:

try:
    # Some risky code
    risky_code()
except Exception as e:
    print(f"An error occurred: {e}")

Note: It’s generally better to catch specific exceptions rather than using a generic except Exception unless you have a good reason (e.g., logging).

Raising Exceptions:

Sometimes you may want to raise exceptions manually using the raise keyword:

def divide(x, y):
    if y == 0:
        raise ValueError("Cannot divide by zero!")
    return x / y

try:
    result = divide(10, 0)
except ValueError as e:
    print(f"Error: {e}")  # Output: Error: Cannot divide by zero!

Custom Exceptions:

You can define your own exceptions by creating a custom exception class that inherits from Python’s built-in Exception class:

class CustomError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

try:
    raise CustomError("Something went wrong!")
except CustomError as e:
    print(f"Caught an error: {e}")  # Output: Caught an error: Something went wrong!

Summary:

Use the try block to write code that might raise an exception.
Handle exceptions using the except block, and optionally specify the type of exception.
The else block runs when no exception occurs in the try block.
The finally block runs regardless of whether an exception was raised or not, often used for cleanup.
You can catch multiple exceptions, raise your own exceptions, and define custom exception types for better control over error handling.

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

Answer:

The Global Interpreter Lock (GIL) is a mutex (short for mutual exclusion) that allows only one thread to execute Python bytecode at a time, even on multi-core systems. It is an important feature of the CPython implementation of Python, which is the most widely used Python interpreter.

Purpose of the GIL:

The GIL is primarily used to simplify memory management and ensure that Python’s memory management (specifically the reference counting mechanism for garbage collection) is thread-safe. Without the GIL, there would be a need for more complex locking mechanisms, which could introduce performance overheads in some cases.

Key Points:

Single Thread Execution:
- Even though Python allows the creation of multiple threads, the GIL ensures that only one thread can execute Python bytecode at a time. This means that in multi-threaded programs, even on multi-core machines, only one thread runs the Python code at any given moment.
Thread Safety:
- The GIL makes the CPython interpreter simpler to implement because it avoids the need for fine-grained locks to manage memory. This simplifies the implementation of the CPython runtime and the reference counting mechanism for garbage collection.
Multithreading vs. Multiprocessing:
- Because of the GIL, multithreading in Python doesn’t fully utilize multiple CPU cores for CPU-bound tasks. This is especially problematic in programs that require heavy computation, as threads end up competing for the GIL.
- However, Python’s multiprocessing module allows you to create multiple processes, each with its own Python interpreter and, thus, its own GIL. This allows for true parallelism on multi-core systems. When using multiprocessing, Python can utilize multiple cores because each process runs independently and has its own GIL.
Impact on Performance:
- CPU-bound programs: In programs that perform a lot of computation, the GIL can lead to performance bottlenecks, as only one thread can execute at a time. In this case, multiprocessing (using separate processes) or switching to external libraries (e.g., NumPy, which uses optimized C code) might help.
- I/O-bound programs: For programs that spend a lot of time waiting for I/O (such as reading files or network requests), the GIL is less of an issue because the GIL is released during I/O operations. This means that threads can still be useful in I/O-bound scenarios to improve concurrency, even though the threads don’t run in parallel.

Example:

import threading
import time

def count():
    for i in range(5):
        print(i)
        time.sleep(1)

# Create two threads
thread1 = threading.Thread(target=count)
thread2 = threading.Thread(target=count)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

In this example, even though we have two threads (thread1 and thread2), the GIL ensures that only one thread runs at a time, and we won’t see the threads running in parallel. The output will alternate between the threads.

The GIL and CPython:

The CPython interpreter (the most widely used Python implementation) is the one that uses the GIL.
Other Python implementations, like Jython (Python for Java) and IronPython (Python for .NET), do not have a GIL and handle multi-threading differently.

Workarounds and Alternatives:

Multiprocessing:

Use the multiprocessing module to bypass the GIL for CPU-bound tasks, as it creates separate processes with their own GIL.

Example:

from multiprocessing import Process

def count():
    for i in range(5):
        print(i)

if __name__ == "__main__":
    process1 = Process(target=count)
    process2 = Process(target=count)

    process1.start()
    process2.start()

    process1.join()
    process2.join()

Use of C Extensions:
- Libraries like NumPy and Pandas use C extensions and release the GIL when performing computationally heavy tasks, allowing true parallel execution in such cases.
Asyncio:
- For I/O-bound tasks, the asyncio module in Python allows asynchronous programming, which doesn’t rely on the GIL to achieve concurrency.

Summary:

The Global Interpreter Lock (GIL) in Python ensures thread safety but limits concurrency by allowing only one thread to execute Python bytecode at a time.
The GIL can become a bottleneck for CPU-bound tasks, but it has less impact on I/O-bound tasks.
For CPU-bound parallelism, the multiprocessing module or C extensions are often preferred.
The GIL is specific to the CPython implementation of Python, and other implementations like Jython and IronPython don’t have this limitation.

Question: What are Python’s built-in functions and libraries?

Answer:

Python offers a rich set of built-in functions and a comprehensive standard library that simplifies development by providing a wide range of utilities, modules, and functions. These built-in functions and libraries are included with Python and don’t require external installations.

1. Python Built-in Functions:

These functions are available without importing any modules. They perform common operations such as handling data types, interacting with the system, or performing computations.

Common Built-in Functions:

print(): Outputs text to the console.
```
print("Hello, World!")
```
len(): Returns the length (number of items) of an object.
```
len([1, 2, 3])  # 3
```
type(): Returns the type of an object.
```
type("hello")  # <class 'str'>
```
input(): Reads input from the user.
```
name = input("Enter your name: ")
```
range(): Generates a sequence of numbers (used in loops).
```
for i in range(5):
    print(i)
```
sum(): Returns the sum of an iterable (e.g., a list or tuple).
```
sum([1, 2, 3])  # 6
```
min() and max(): Return the smallest and largest item from an iterable, respectively.
```
min([1, 2, 3])  # 1
max([1, 2, 3])  # 3
```
sorted(): Returns a sorted list from the elements of any iterable.
```
sorted([3, 1, 2])  # [1, 2, 3]
```
abs(): Returns the absolute value of a number.
```
abs(-5)  # 5
```
isinstance(): Checks if an object is an instance of a specific class or a tuple of classes.
```
isinstance(5, int)  # True
```
id(): Returns the unique identifier of an object.
```
id("hello")  # Unique id
```

dir(): Returns a list of attributes and methods of an object.

dir("hello")  # ['__class__', '__delattr__', '__dict__', ...]

help(): Provides information about a Python object or module.
```
help(str)  # Displays help on the string class
```
eval(): Evaluates a string as a Python expression and returns the result.
```
eval("2 + 3")  # 5
```
all() and any(): Return True if all or any elements in an iterable are true, respectively.
```
all([True, False])  # False
any([True, False])  # True
```
zip(): Combines multiple iterables (like lists or tuples) element-wise into an iterator of tuples.
```
zip([1, 2], ['a', 'b'])  # [(1, 'a'), (2, 'b')]
```

Object-Oriented Functions:

callable(): Checks if an object appears callable (e.g., a function or method).
```
callable(print)  # True
```

getattr(), setattr(), hasattr(), and delattr(): Work with object attributes.

class MyClass:
    def __init__(self):
        self.x = 5
        
obj = MyClass()
getattr(obj, 'x')  # 5

2. Python Standard Library:

Python’s standard library includes many built-in modules and packages for a wide range of functionalities. Some common and useful libraries are:

Data Structures and Algorithms:

collections: Provides specialized container datatypes like Counter, deque, OrderedDict, and defaultdict.

from collections import Counter
count = Counter("hello")
print(count)  # Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})

heapq: Implements a heap queue (priority queue).

import heapq
heap = [1, 3, 2, 4]
heapq.heapify(heap)
print(heap)  # [1, 3, 2, 4]

Mathematics and Numbers:

math: Provides mathematical functions (e.g., sin(), cos(), sqrt(), etc.).
```
import math
math.sqrt(16)  # 4.0
```

random: Generates random numbers and selections.

import random
random.choice([1, 2, 3])  # Randomly returns one of the items

statistics: Provides functions for statistical operations (mean, median, etc.).
```
import statistics
statistics.mean([1, 2, 3, 4, 5])  # 3
```

File and Directory Handling:

os: Provides functions to interact with the operating system (e.g., file system operations, environment variables).
```
import os
os.getcwd()  # Returns the current working directory
```
shutil: High-level file operations (copying, moving, removing files, etc.).
```
import shutil
shutil.copy("source.txt", "destination.txt")
```

glob: Used for file pattern matching (like wildcard searches).

import glob
glob.glob("*.txt")  # Finds all .txt files in the directory

Web Development:

http: A module for HTTP client and server functionality.
- http.client, http.cookiejar, http.server

urllib: A module for working with URLs (fetching data from websites).

import urllib.request
response = urllib.request.urlopen('https://www.example.com')
html = response.read()

json: Used to work with JSON data (encoding and decoding).

import json
json_data = json.dumps({"name": "Alice", "age": 30})
print(json_data)  # '{"name": "Alice", "age": 30}'

Concurrency:

threading: Provides support for working with threads.

import threading
def print_hello():
    print("Hello from thread!")
t = threading.Thread(target=print_hello)
t.start()

asyncio: Asynchronous programming support (handling concurrency with coroutines).

import asyncio
async def main():
    print("Hello, async!")
asyncio.run(main())

Error Handling:

traceback: Provides utilities for working with Python exceptions and stack traces.

import traceback
try:
    1 / 0
except ZeroDivisionError:
    traceback.print_exc()  # Prints the traceback of the error

Other Utility Libraries:

time: Functions for manipulating time (e.g., delays, time measurements).
```
import time
time.sleep(1)  # Pauses for 1 second
```
sys: Provides access to system-specific parameters and functions (e.g., command-line arguments, exit status).
```
import sys
sys.argv  # List of command-line arguments passed to the script
```

platform: Retrieves information about the platform (e.g., OS type).

import platform
platform.system()  # 'Windows', 'Linux', or 'Darwin'

Summary:

Built-in Functions: Python includes many built-in functions such as print(), len(), type(), sum(), etc., which make it easier to handle basic tasks.
Standard Library: Python’s standard library provides modules for handling a wide variety of tasks, including file I/O, mathematical functions, system interaction, and web development, without the need for third-party libraries.

By leveraging Python’s built-in functions and libraries, you can significantly speed up development and reduce the need for external dependencies.

Question: What are lambda functions in Python?

Answer:

A lambda function in Python is a small, anonymous function defined using the lambda keyword. Unlike a regular function defined with the def keyword, a lambda function can have any number of arguments but can only contain a single expression. The result of the expression is automatically returned by the lambda function.

Lambda functions are often used for short, throwaway functions, especially when the function is required temporarily or when a full function definition is not necessary.

Syntax:

lambda arguments: expression

arguments: A comma-separated list of input parameters.
expression: A single expression whose value is returned.

Key Characteristics of Lambda Functions:

Anonymous: Lambda functions do not need to be named.
Single Expression: A lambda function can contain only a single expression (no statements like loops or conditionals).
Return Value: The result of the expression is automatically returned without needing to use the return keyword.
Used for Short Functions: Lambdas are typically used when you need a simple function for a short duration, often in places where you don’t want to formally define a function.

Example 1: Basic Lambda Function

# Lambda function to add two numbers
add = lambda x, y: x + y

print(add(2, 3))  # 5

Here, the lambda function lambda x, y: x + y takes two arguments x and y, and returns their sum.

Example 2: Lambda Function Used with `sorted()`

Lambda functions are often used in functions like sorted(), where you can specify a custom sorting key.

# Sort a list of tuples based on the second element
data = [(1, 3), (2, 2), (4, 1)]
sorted_data = sorted(data, key=lambda x: x[1])

print(sorted_data)  # [(4, 1), (2, 2), (1, 3)]

In this case, the lambda function lambda x: x[1] is used to sort the list of tuples based on the second element.

Example 3: Lambda Function with `filter()`

Lambda functions are also frequently used with functional programming tools like filter(), map(), and reduce().

# Filter out even numbers using lambda and filter
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

print(even_numbers)  # [2, 4, 6]

Here, the lambda function lambda x: x % 2 == 0 checks if a number is even and filters the list accordingly.

Example 4: Lambda Function with `map()`

The map() function applies a lambda function to each item in an iterable (like a list).

# Multiply each number in a list by 2
numbers = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, numbers))

print(doubled)  # [2, 4, 6, 8]

In this example, the lambda function lambda x: x * 2 is applied to each item in the list numbers.

When to Use Lambda Functions:

Short-term functions: When you need a simple function for a short period of time and do not want to formally define it with a def block.
Higher-order functions: When passing a function as an argument to higher-order functions like map(), filter(), or sorted().
Readability: When the function is simple and you don’t want to clutter the code with a separate function definition.

Limitations of Lambda Functions:

Single expression only: You cannot have multiple expressions or statements in a lambda function (e.g., no loops, conditionals, or multiple operations).
Readability: Overuse of lambda functions, especially for complex expressions, can reduce code readability. In those cases, defining a full function using def might be clearer.

Example: Lambda vs. Regular Function

# Regular function definition
def multiply(x, y):
    return x * y

print(multiply(2, 3))  # 6

# Lambda function
multiply_lambda = lambda x, y: x * y
print(multiply_lambda(2, 3))  # 6

Both functions perform the same operation, but the lambda function is more concise.

Summary:

Lambda functions are anonymous functions defined with the lambda keyword.
They can have any number of arguments, but only one expression.
They are useful for short, simple operations and are commonly used in functional programming tools like map(), filter(), and sorted().
While they provide conciseness, excessive use can make code less readable.

Question: What is the purpose of the `pass` statement in Python?

Answer:

The pass statement in Python is a null operation. It is used when a statement is syntactically required, but you do not want to perform any action or logic. Essentially, pass is a placeholder that allows you to write empty code blocks or define functions, classes, or loops that don’t yet contain code but need to be syntactically correct.

Key Use Cases of `pass`:

Empty Functions or Methods: Sometimes, you might want to define a function or method without implementing its logic immediately (e.g., during development or for a stub function).
```
def my_function():
    pass  # Function defined but does nothing yet
```
Empty Classes: Similar to functions, you can use pass to create an empty class definition, which can be filled with attributes or methods later.
```
class MyClass:
    pass  # Class with no methods or properties yet
```

Empty Loops or Conditionals: The pass statement is useful when you need a loop or conditional statement for the syntax, but you don’t want it to do anything yet.

for i in range(5):
    pass  # Loop doesn't do anything, just a placeholder

if some_condition:
    pass  # No action for this condition, but required for the structure

Handling try-except Blocks: pass can be used in an exception handling block when you want to handle an exception but don’t need to take any specific action.
```
try:
    risky_operation()
except ValueError:
    pass  # Ignore the ValueError and do nothing
```
Abstract Methods: In object-oriented programming, pass can be used in an abstract method or base class that serves as a blueprint, where the implementation is left to subclasses.
```
class BaseClass:
    def my_abstract_method(self):
        pass  # No implementation, must be overridden in subclass
```

Why Use `pass`?

Maintaining Syntax: Python requires that the body of functions, classes, loops, conditionals, and exception blocks contain at least one statement. If you don’t intend to perform any action yet, pass allows you to maintain proper syntax without raising an error.
Code Stubs: When working on a large project, you might define empty functions, classes, or loops as placeholders while you work on other parts of the code. pass helps you avoid leaving the code incomplete or throwing errors.
Readability: pass makes it clear that you intentionally left a code block empty rather than accidentally leaving it blank or forgetting to add functionality.

Example 1: Empty Function Definition

def do_nothing():
    pass  # No action is performed

Example 2: Empty Class Definition

class Animal:
    pass  # Animal class is defined but has no methods or properties yet

Example 3: Empty Loop

for i in range(10):
    pass  # Loop body does nothing

Summary:

The pass statement in Python is a placeholder that allows you to write syntactically correct code blocks without performing any actual operations. It is commonly used for defining functions, classes, or loops that are not yet implemented or when you want to ignore certain conditions or exceptions in the code.

Question: What are Python’s key features?

Answer:

Python is a versatile, high-level programming language known for its simplicity and readability. Its design philosophy emphasizes code readability and a clean, straightforward syntax. Below are some of Python’s key features:

1. Easy to Learn and Use

Simple Syntax: Python’s syntax is clear and easy to understand, making it an excellent language for beginners.
Readable Code: Python emphasizes readability, using indentation to define code blocks instead of curly braces, making it easier to follow.

Example:

def greet(name):
    print(f"Hello, {name}!")
greet("Alice")

2. Interpreted Language

No Compilation: Python is an interpreted language, which means the code is executed line by line. This allows for quick testing and debugging.
Portability: Python code can run on any machine that has a Python interpreter, making it highly portable.

3. Dynamically Typed

No Variable Declarations: You do not need to explicitly declare the type of a variable. Python automatically infers the type based on the value assigned.
Flexible: This dynamic typing provides flexibility but can sometimes lead to runtime errors.

Example:

x = 5       # x is an integer
x = "hello"  # Now x is a string

4. High-Level Language

Python abstracts away most of the low-level details (like memory management), making it easier for developers to focus on solving problems rather than managing hardware-specific issues.

5. Object-Oriented

Supports OOP: Python supports object-oriented programming (OOP), which allows for creating and using objects. It supports the core principles of OOP, such as inheritance, polymorphism, and encapsulation.

Example:

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name} makes a sound.")

dog = Animal("Dog")
dog.speak()  # Dog makes a sound.

6. Extensive Standard Library

Rich Libraries: Python comes with a large standard library that provides modules for handling file I/O, networking, web scraping, data manipulation, machine learning, and more.
Third-party Libraries: Additionally, there is a vast ecosystem of third-party libraries and frameworks available via the Python Package Index (PyPI), enabling Python to be used in a wide range of fields.

7. Cross-Platform

Platform Independence: Python is platform-independent, meaning Python code can run on various platforms like Windows, macOS, Linux, etc., without modification.
Compatibility with Other Languages: Python can easily integrate with other languages such as C, C++, and Java.

8. Integrated with Other Languages

C and C++ Integration: Python can integrate with other programming languages like C, C++, Java, and even .NET using specialized libraries or interfaces.
Extensions: You can extend Python’s functionality with C/C++ libraries and code.

9. Interpreted Interactive Mode

Python provides an interactive mode where you can test small code snippets and experiment with code quickly in the Python shell or REPL (Read-Eval-Print Loop).
This is helpful for rapid prototyping, debugging, and learning.

10. Support for Functional Programming

Python supports functional programming concepts such as first-class functions, lambda expressions, map(), filter(), and reduce().
This allows Python to be used in both an object-oriented and a functional paradigm.

Example:

# Using map() and lambda function
numbers = [1, 2, 3, 4]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers)  # [1, 4, 9, 16]

11. Garbage Collection

Automatic Memory Management: Python automatically handles memory management using garbage collection, freeing up unused memory automatically.
Reference Counting: Python uses reference counting to keep track of memory objects and deallocates them when they are no longer in use.

12. Scalable and Extensible

Scalable: Python is suitable for both small scripts and large-scale applications. Its modularity and large library ecosystem make it ideal for various applications, from web development to machine learning.
Extensible: You can write Python code in C/C++ to improve performance when needed, or extend Python using C libraries.

13. Support for Multithreading and Multiprocessing

Multithreading: Python supports multithreading, which allows the execution of multiple threads within a single process. However, the Global Interpreter Lock (GIL) may limit true parallel execution in multi-core systems.
Multiprocessing: Python supports multiprocessing, which allows the creation of multiple processes, enabling true parallelism for CPU-bound tasks.

14. Readable and Clean Code

Python emphasizes writing clean, readable, and maintainable code. Its use of indentation instead of braces ({}) forces programmers to use consistent formatting, making the code visually uniform and easier to understand.

15. Wide Adoption and Community Support

Python is one of the most popular languages in the world, widely used across many industries (web development, data science, automation, etc.). This has resulted in a strong community with extensive support and resources available online.
The vast number of tutorials, documentation, and third-party libraries ensures that Python remains a go-to language for many developers.

16. Used in Diverse Domains

Python is versatile and used in a variety of domains including:
- Web Development: Frameworks like Django and Flask.
- Data Science: Libraries like NumPy, Pandas, and Matplotlib.
- Machine Learning: Libraries like TensorFlow, Keras, and PyTorch.
- Automation/Scripting: For automating tasks and writing small scripts.
- Game Development: Libraries like Pygame.

Summary:

Python’s key features include its simple syntax, high readability, dynamic typing, extensive libraries, cross-platform compatibility, object-oriented and functional programming support, and strong community. These features make Python a powerful language for a wide range of applications, from web development and data science to artificial intelligence and automation.

Question: What is a Python module and how do you import one?

Answer:

What is a Python Module?

A Python module is a file containing Python definitions and statements, such as functions, classes, and variables. Modules allow you to organize and structure your Python code into multiple files, making it easier to maintain and reuse code across different programs. A module can be thought of as a collection of related functions, variables, and classes, all bundled together in a single file with a .py extension.

For example, a file named math_operations.py containing a function to add two numbers would be a module:

# math_operations.py
def add(x, y):
    return x + y

How to Import a Python Module?

To use the functionality defined in a module, you must import it into your current script or program. There are several ways to import a module or parts of a module:

1. Importing the Entire Module

You can import the entire module using the import keyword. This allows you to access all the functions, classes, and variables defined in that module by prefixing them with the module name.

Example:

import math_operations  # Importing the entire module

result = math_operations.add(3, 5)
print(result)  # Output: 8

Here, the module math_operations is imported, and the add() function is accessed using math_operations.add().

2. Importing Specific Items from a Module

You can import specific functions, classes, or variables from a module to avoid the need to prefix them with the module name.

Example:

from math_operations import add  # Importing only the 'add' function

result = add(3, 5)
print(result)  # Output: 8

In this case, only the add function is imported directly, and you can use it without the module name prefix.

3. Importing All Items from a Module

You can import all functions and classes from a module using the * (wildcard) operator. However, this is generally not recommended because it may lead to conflicts between function names in larger projects.

Example:

from math_operations import *  # Importing everything from the module

result = add(3, 5)
print(result)  # Output: 8

This approach imports all names defined in the module into the current namespace, which means you can access everything directly (e.g., add() in this case).

4. Renaming a Module during Import

You can assign a custom name to a module when importing it using the as keyword. This is helpful if the module has a long name or if you want to avoid name conflicts.

Example:

import math_operations as mo  # Renaming the module

result = mo.add(3, 5)
print(result)  # Output: 8

Here, math_operations is imported as mo, allowing you to use a shorter name for the module.

5. Importing from a Module in Another Directory (Using `sys.path`)

If the module is located in a different directory, you can modify the sys.path list (which stores the search paths for modules) to include the directory where your module is located.

Example:

import sys
sys.path.append('/path/to/your/module')

import math_operations

This will allow you to import a module that is not in the current working directory or standard library directories.

Python Standard Library Modules

Python comes with a rich set of standard modules that you can import and use in your programs. Some common examples include:

math: Provides mathematical functions like math.sqrt(), math.pi, etc.
os: Provides functions to interact with the operating system (e.g., file and directory manipulation).
datetime: Provides classes for working with dates and times.
random: Implements random number generation and shuffling.

Example (Using the `math` Module):

import math

result = math.sqrt(16)
print(result)  # Output: 4.0

Summary:

What is a Python module?
A Python module is a file containing Python code (functions, variables, classes). It allows code to be organized into separate files for better maintainability and reuse.
How to import a module?
- Use import module_name to import the entire module.
- Use from module_name import function_name to import specific functions, classes, or variables.
- Use import module_name as alias to rename a module during import.
- Use from module_name import * to import all items from a module (generally discouraged).
- Modify sys.path to import modules from other directories.

By importing modules, you can leverage code written by others, including Python’s extensive standard library and third-party libraries, making your development process more efficient.

Question: How does Python handle variable scope and namespaces?

Answer:

In Python, variable scope and namespaces refer to how and where variables are stored, accessed, and modified within a program. Understanding the concepts of scope and namespaces is essential to writing clean and efficient code and avoiding issues like variable name conflicts or unintended modifications.

1. What is a Namespace?

A namespace in Python refers to a container that holds a collection of variable names (keys) and their corresponding objects (values). Each variable name in Python is a reference to an object in memory, and a namespace ensures that each name refers to the correct object.

There are several types of namespaces in Python, including:

Local Namespace: This refers to the namespace inside a function or method. Variables defined inside a function are in the local namespace of that function.
Enclosing Namespace: This refers to the namespace of any enclosing functions, like closures. If a function is defined inside another function, the inner function has access to variables from the outer function’s namespace.
Global Namespace: This refers to the namespace at the level of the main program. Variables defined at the top level of a module are in the global namespace of that module.
Built-in Namespace: This contains Python’s built-in functions and exceptions, like print(), len(), and ValueError. These are always available for use throughout the program.

Each namespace is independent of the others, meaning that variables in one namespace do not directly affect variables in another namespace.

2. What is Variable Scope?

The scope of a variable in Python refers to the region of the code where the variable is accessible. The scope determines where a variable can be used, read, or modified. Python uses the LEGB rule to resolve variable names, which stands for:

Local: The innermost scope, which includes variables defined inside a function or method.
Enclosing: The scope of any enclosing function, for example, when one function is nested inside another.
Global: The scope of variables defined at the top level of a module or script.
Built-in: The outermost scope, containing names like print(), len(), and exceptions.

Python will search for a variable in the order of LEGB—starting with the local scope, then moving to the enclosing scope, then the global scope, and finally the built-in scope. If a variable is not found in any of these scopes, a NameError will occur.

3. The LEGB Rule:

Python searches for variables based on the LEGB rule. Let’s break this down:

Local Scope (L)

Variables defined inside a function or a block of code.
These variables are only accessible inside the function or block.

Example:

def func():
    x = 10  # Local variable
    print(x)

func()  # Output: 10
# print(x)  # This will raise a NameError because 'x' is local to func

Enclosing Scope (E)

This scope is relevant when you have nested functions (functions inside functions).
Variables from the outer (enclosing) function are accessible from the inner function.

Example:

def outer():
    x = 5  # Variable in enclosing scope
    def inner():
        print(x)  # Accessing variable from the enclosing function
    inner()

outer()  # Output: 5

Global Scope (G)

Variables defined at the top level of a script or module.
These variables are accessible throughout the module.

Example:

x = 20  # Global variable

def func():
    print(x)  # Accessing the global variable

func()  # Output: 20

Built-in Scope (B)

This scope includes Python’s built-in functions, exceptions, and other objects like print(), len(), range(), and others.
These names are always available throughout the program.

Example:

print(len("Hello"))  # len() is a built-in function

4. Modifying Variables in Different Scopes

Python distinguishes between local, global, and nonlocal variables when you want to modify variables from different scopes.

Local Variables:

Variables defined inside a function or method are local to that function. They can be modified directly within the function.

Global Variables:

To modify a global variable inside a function, you must use the global keyword.

Example (Global Variable):

x = 10  # Global variable

def modify_global():
    global x  # Declare x as global
    x = 20  # Modify global variable

modify_global()
print(x)  # Output: 20

Enclosing (Nonlocal) Variables:

If you want to modify a variable in the enclosing function’s scope (but not in the global scope), you use the nonlocal keyword. This is typically used in nested functions.

Example (Enclosing Variable):

def outer():
    x = 5  # Enclosing variable
    def inner():
        nonlocal x  # Declare x as nonlocal (from the enclosing scope)
        x = 10  # Modify the enclosing variable
    inner()
    print(x)  # Output: 10

outer()

5. Example with LEGB Rule

Consider this example with all scopes involved:

x = 50  # Global variable

def outer():
    x = 10  # Enclosing variable
    def inner():
        x = 5  # Local variable
        print(x)  # This will print the local x

    inner()
    print(x)  # This will print the enclosing x

outer()
print(x)  # This will print the global x

Output:

5  # Printed from the inner function (local x)
10  # Printed from the outer function (enclosing x)
50  # Printed from the global scope (global x)

6. The `globals()` and `locals()` Functions

globals(): Returns a dictionary of the global namespace (variables at the module level).
locals(): Returns a dictionary of the local namespace (variables inside a function).

Example:

x = 100  # Global variable

def test():
    y = 200  # Local variable
    print(globals())  # Prints the global namespace (including 'x')
    print(locals())  # Prints the local namespace (including 'y')

test()

Summary:

Namespace is a container where variable names are mapped to objects. Python has four main namespaces: local, enclosing, global, and built-in.
Scope refers to the region where a variable is accessible. Python resolves variable names using the LEGB rule (Local -> Enclosing -> Global -> Built-in).
To modify variables from different scopes, Python uses the global keyword (for global scope) and nonlocal keyword (for enclosing scopes).
Functions like globals() and locals() can be used to access the current namespace.

By understanding variable scope and namespaces in Python, you can write cleaner, more efficient, and less error-prone code.

Question: What is the difference between `del` and `remove()` in Python?

Answer:

Both del and remove() are used to remove elements in Python, but they work in different ways and have distinct use cases. Here’s a breakdown of the differences:

1. `del` Statement

The del statement is used to delete an object or a variable entirely. It can be used to remove elements from lists, delete variables, or even delete entire slices of a list.

Key Points about `del`:

Used for deleting objects: You can use del to remove variables, list elements, or even dictionary keys.
Works by index: When used with a list, del removes the item at a specific index.
Can delete entire slices: It can be used to delete multiple elements in a list using slicing.

Example 1: Deleting a Variable

x = 10
del x  # Deletes the variable x
# print(x)  # This will raise a NameError because x no longer exists

Example 2: Deleting an Element by Index from a List

my_list = [10, 20, 30, 40, 50]
del my_list[2]  # Removes the element at index 2 (value 30)
print(my_list)  # Output: [10, 20, 40, 50]

Example 3: Deleting a Slice of a List

my_list = [10, 20, 30, 40, 50]
del my_list[1:3]  # Removes elements at index 1 and 2 (values 20 and 30)
print(my_list)  # Output: [10, 40, 50]

Important Notes:

The del statement does not return any value.
It raises an error if the specified index is out of range or if the variable doesn’t exist.

2. `remove()` Method

The remove() method is a list method that removes the first occurrence of a specific value from a list. If the value is not found, it raises a ValueError.

Key Points about `remove()`:

Used for removing by value: It removes the first occurrence of the specified value in the list.
Modifies the list in place: The list is modified, and the method does not return a new list.
Raises an error if the value is not found: If the specified value is not present in the list, it raises a ValueError.

Example 1: Removing an Element by Value

my_list = [10, 20, 30, 40, 50]
my_list.remove(30)  # Removes the first occurrence of the value 30
print(my_list)  # Output: [10, 20, 40, 50]

Example 2: Value Not Found (Raises `ValueError`)

my_list = [10, 20, 30, 40, 50]
# my_list.remove(60)  # This will raise a ValueError because 60 is not in the list

Key Differences:

Aspect	`del`	`remove()`
Type of Removal	Removes by index or deletes the entire object.	Removes by value (first occurrence).
Syntax	`del list[index]` or `del variable`	`list.remove(value)`
Return Value	Does not return anything (raises error on failure).	Does not return anything (raises `ValueError` if the value is not found).
Error Handling	Raises an `IndexError` if the index is out of range.	Raises a `ValueError` if the value is not found.
Used With	Lists, dictionaries, or variables.	Only with lists.
Can Remove Multiple Elements	Can delete slices (e.g., `del list[start:end]`).	Can only remove one element at a time (the first occurrence of the value).

Summary:

del is a Python statement that is used to remove an element at a specific index from a list, delete a variable, or delete an entire slice of a list.
remove() is a list method that removes the first occurrence of a specific value from the list. If the value is not present, it raises a ValueError.

Use del when you want to remove an element by index or delete an entire variable, and use remove() when you need to remove an element by its value.

If you can’t get enough from this article, Aihirely has plenty more related information, such as python-3.x interview questions, python-3.x interview experiences, and details about various python-3.x job positions. Click here to check it out.

Most Frequently asked python-3.x Interview Questions (2024)

Question: What is the difference between Python 2.x and Python 3.x?

Answer:

1. Print Statement vs. Print Function

2. Integer Division

3. Unicode Handling

4. Iterators and Generators

5. Exception Handling Syntax

6. Input Handling

7. Standard Library Changes

8. Function Annotations

9. Libraries and Third-Party Support

10. Performance Improvements

11. End of Life (EOL)

Summary of Key Differences:

Conclusion:

Question: What are Python decorators?

Answer:

How Do Python Decorators Work?

Basic Syntax of a Decorator:

Example of a Simple Decorator:

Components of a Decorator:

Example with Arguments:

Using Built-in Decorators:

Chaining Decorators:

Practical Use Cases for Decorators:

Summary:

Question: What is the difference between a shallow copy and a deep copy in Python?

Answer:

1. Shallow Copy

Key Points:

Example of Shallow Copy:

2. Deep Copy

Key Points:

Example of Deep Copy:

Summary of Differences:

When to Use:

Question: What is the self keyword in Python?

Answer:

Key Points:

Example of self in Action:

How self Works in Method Calls:

Why self is Important:

Common Misunderstandings:

Example with Multiple Instances:

Summary:

Question: What is the difference between @staticmethod and @classmethod in Python?

Answer:

1. @staticmethod (Static Method)

Example of @staticmethod:

2. @classmethod (Class Method)

Example of @classmethod:

Summary of Differences:

When to Use:

Factory Method Example with @classmethod:

Question: How does Python handle memory management?

Answer:

1. Reference Counting

Example:

2. Garbage Collection

How Garbage Collection Works:

Generational Garbage Collection:

Example of Cyclic Garbage Collection:

3. Memory Pools

4. The del Statement

Example of del:

5. Memory Leaks in Python

6. Tools for Memory Management

Summary of Python’s Memory Management:

Question: What are Python generators and how do they work?

Answer:

How do Python Generators Work?

1. yield Keyword

2. Creating a Generator Function

Example of a Simple Generator:

3. How Generators are Different from Regular Functions

Key Characteristics of Python Generators

Example of Using next() with a Generator

Generator Expressions

Example of a Generator Expression:

Example of `self` in Action:

How `self` Works in Method Calls:

Why `self` is Important:

Question: What is the difference between `@staticmethod` and `@classmethod` in Python?

1. `@staticmethod` (Static Method)

Example of `@staticmethod`:

2. `@classmethod` (Class Method)

Example of `@classmethod`:

Factory Method Example with `@classmethod`:

4. The `del` Statement

Example of `del`:

1. `yield` Keyword

Example of Using `next()` with a Generator

Question: What is the difference between `is` and `==` in Python?

Question: What is the purpose of the `with` statement in Python?

Example 2: Lambda Function Used with `sorted()`

Example 3: Lambda Function with `filter()`