Python is popular for many reasons, including:

• Readability: Python’s syntax is simple and close to English, making it easy to learn and read.
• Interpreted Language: Code is executed line-by-line, which simplifies debugging.
• Dynamically Typed: Variables don’t require explicit declaration of type.
• Object-Oriented: Python supports OOP concepts such as inheritance, polymorphism, and encapsulation.
• Extensive Libraries: Python has a large standard library and extensive third-party modules.

Python has several built-in data types:

• Numeric: int, float, complex
• Sequence: str, list, tuple
• Mapping: dict
• Set: set, frozenset
• Boolean: bool

A list is a mutable (modifiable) ordered collection that can hold items of different data types. A tuple, however, is immutable (cannot be modified after creation) and ordered. Lists are defined with square brackets [], while tuples use parentheses ().

Example:

my_list = [1, 2, 3]  # List
my_tuple = (1, 2, 3)  # Tuple

self is a reference to the current instance of a class, used to access variables and methods associated with the instance. It is the first parameter in instance methods and must be explicitly included in the method definition.

__init__ is a special method in Python, known as the constructor. It initializes new objects and allows for setting initial values of an object’s properties.

Example:

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

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, limiting Python to execute only one thread at a time. This can impact performance in CPU-bound tasks.

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, limiting Python to execute only one thread at a time. This can impact performance in CPU-bound tasks.

• copy(): Creates a shallow copy of an object, meaning only the outer object is copied, not the nested objects.
• deepcopy(): Creates a deep copy, meaning all levels of nested objects are copied recursively.

Example:

import copy
list1 = [[1, 2], [3, 4]]
shallow = copy.copy(list1)
deep = copy.deepcopy(list1)

• *args: Allows you to pass a variable number of positional arguments to a function.
• **kwargs: Allows you to pass a variable number of keyword arguments (as a dictionary) to a function.

Example:

def example_func(*args, **kwargs):
    print("Positional:", args)
    print("Keyword:", kwargs)

Python handles exceptions with try, except, else, and finally blocks.

Example:

try:
    value = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print("Division successful")
finally:
    print("Done")

A generator is a special type of iterator that returns a lazy sequence of values using the yield keyword. Unlike regular functions, generators do not store all values in memory but generate them on the fly.

Example:

def gen_numbers():
    for i in range(3):
        yield i

Decorators are functions that modify the behavior of another function. They allow you to wrap a function with additional functionality, often used for logging, validation, or caching.

Example:

def my_decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper

@my_decorator
def hello():
    print("Hello!")

hello()

Output:

Before function
Hello!
After function

You can reverse a string using slicing:

text = "Python"
reversed_text = text[::-1]
print(reversed_text)  # Output: nohtyP

• map(): Applies a function to every item in an iterable, returning an iterator with the results.
• filter(): Filters items in an iterable based on a function that returns True or False.

Example:

numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))  # Output: [1, 4, 9, 16]
even = list(filter(lambda x: x % 2 == 0, numbers))  # Output: [2, 4]

Python has an automatic memory management system that uses a combination of reference counting and a garbage collector. When an object’s reference count drops to zero, Python’s garbage collector reclaims the memory.

This condition checks whether the current file is being run directly or imported as a module. Code within this block only runs if the file is executed as the main program, not when imported.

Example:

if __name__ == "__main__":
    print("Running directly")
else:
    print("Imported as module")

A lambda function is an anonymous, one-line function often used for short operations or as arguments in higher-order functions.

Example:

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

List slicing allows you to access a subset of a list by specifying start, stop, and step values.

Example:

numbers = [0, 1, 2, 3, 4, 5]
subset = numbers[1:5:2]
print(subset)  # Output: [1, 3]