Python Interview Questions

In a dynamically typed language, variable types are not explicitly declared and can change during runtime. Python is an example of a dynamically typed language, allowing flexibility in variable assignments without specifying data types explicitly.

Both lists and tuples are sequences in Python, but lists are mutable, meaning their elements can be modified after creation. Tuples, on the other hand, are immutable, and their elements cannot be changed once defined. Tuples are typically used for fixed collections of items, while lists are more flexible.

1. Global attributes: Variables declared outside any function or class, accessible throughout the entire program.
2. Protected attributes: Variables or methods with a single leading underscore, indicating that they are intended for internal use and should not be accessed directly from outside the class or module.
3. Private attributes: Variables or methods with a double leading underscore, providing a stronger indication of internal use and making it more difficult to access from outside the class.

__init__ is a special method in Python classes that is called when an object is created. It is commonly used for initializing the attributes of the object. The double underscores before and after "init" make it a dunder method, indicating its special status in the Python language.

1. break: Used to exit a loop prematurely.
2. continue: Skips the rest of the loop's code and moves to the next iteration.
3. pass: A null operation, serving as a placeholder to ensure syntactic correctness without any actual code execution.

Unit tests are a type of testing where individual units or components of a software application are tested in isolation. In Python, the unit test module provides a framework for creating and running unit tests. Unit tests help ensure that each part of the program functions as intended.

A docstring is a string literal placed at the beginning of a module, function, class, or method definition in Python. It serves as documentation, providing information about the purpose and usage of the code. Docstrings can be accessed using the __doc__ attribute.

Slicing is a technique in Python used to extract a portion of a sequence, such as a list or string. It involves specifying a start index, a stop index, and an optional step value. Slicing allows for creating sublists or substrings from the original sequence.

To make a Python script executable on Unix, follow these steps:

1. Add a shebang line at the top of the script, specifying the path to the Python interpreter. For example: #!/usr/bin/env python3.
2. Set the script file's execution permissions using the chmod command: chmod +x script.py.
3. Execute the script using ./script.py without explicitly invoking the Python interpreter.

Python arrays and lists both represent ordered sequences of elements, but they differ in their functionality. Arrays are part of the ‘array’ module and are more efficient for numerical operations. Lists, part of the core language, are more versatile and can contain elements of different data types. While lists support various operations, arrays are specialized for numerical computations and provide better performance for large datasets.

Python's memory manager is responsible for managing memory in Python. It uses a private heap space to store objects and data structures. The memory manager is responsible for allocating and deallocating memory, and it includes mechanisms such as automatic garbage collection to reclaim memory occupied by objects that are no longer in use.

Dict comprehensions and List comprehensions are concise ways to create dictionaries and lists, respectively. They provide a compact syntax for creating these data structures by specifying the elements or key-value pairs in a single line, using a concise and expressive syntax.

In Python, a lambda function is an unnamed function created using the 'lambda' keyword. It is used for creating small, one-time-use functions without explicitly naming them. Lambdas are often employed for short-term operations in functions like ‘map()’, ‘filter()’, and ‘sorted()’.

If you want to duplicate an object in Python, the ‘copy’ module comes in handy. The ‘copy()’ function creates a shallow copy, while the ‘deepcopy()’ function creates a deep copy, which includes copies of nested objects. Additionally, you can use slicing or the ‘copy’ method for specific data types like lists.

In Python 2, ‘xrange’ is a function that generates values on-the-fly, representing an iterable sequence. It is memory-efficient as it doesn't generate all values at once. In Python 3, ‘range’ itself is implemented like ‘xrange’ in Python 2, making the distinction between them obsolete.

Pickling is the process of converting a Python object into a byte stream, while unpickling is the reverse process of reconstructing the original object from the byte stream. This is commonly used for object serialization and deserialization.

In Python, iterators can be generated using generators. They allow you to iterate over a potentially large sequence of data efficiently, generating values one at a time instead of creating the entire sequence in memory. Generators use the yield keyword to produce values during iteration.

PYTHONPATH is an environment variable in Python that specifies additional directories where the interpreter should look for modules and packages. It is a list of directories separated by colons (or semicolons on Windows) that Python uses to search for imported modules.

The ‘help()’ function provides interactive help for Python objects by displaying their docstrings and other related information. The ‘dir()’ function, on the other hand, returns a list of names in the current local scope or the attributes of an object, showing what is defined or available.

.py files are Python source code files, while .pyc files are compiled bytecode files. When a .py file is run, Python generates a .pyc file to store the compiled bytecode, which can be executed faster in subsequent runs.

In Python, arguments are passed by object reference. When a function is called, references to objects are passed to the function. However, whether the actual object is mutable or immutable determines whether changes made inside the function persist outside of it.

Iterators in Python are objects that implement the ‘__iter__()’and ‘__next__()’ methods, allowing them to be iterated over. Iterators maintain state and produce the next value in a sequence when the ‘__next__()’ method is called.

To delete a file in Python, you can use the ‘os.remove()’ function from the ‘os’ module. This function takes the file path as an argument and deletes the specified file.

python

import os

file_path = 'path/to/your/file.txt'

try:
os.remove(file_path)
print(f"File {file_path} deleted successfully.")
except FileNotFoundError:
print(f"File {file_path} not found.")
except Exception as e:
print(f"An error occurred: {e}")

Negative indexes in Python are used to access elements from the end of a sequence, such as a string or a list. Negative indexing starts from the last element with index -1, allowing for convenient access to elements in reverse order.