With over 38,000 job postings on Indeed.com for Python developers, it’s clear that these knowledgeable programming professionals are in high demand. Furthermore, according to the PYPL PopularitY index, Python remains on top of the charts, taking up 28.52% of the market share.
Used in many different programming scenarios and availed by the biggest companies in the world, Python is here to stay and some in the industry even hold the opinion that it is the future of programming languages.
Be that as it may, interviewing for a developer role can be nerve-wracking no matter how experienced or knowledgable you are.
Interviewers expect candidates to have deep understanding of programming concepts and show an ability to solve complex problems. While the demand for Python developers is high, getting hired isn’t a cake-walk, either.
If you’re appearing for a Python interview soon, this list of the top Python interview questions will help ensure you’ve covered all the bases before heading into the interview.
We’ve covered everything from Python interview questions for freshers to advanced Python programming interview questions in this post.
Python Fresher Interview Questions
#1 What is Python? What benefits does it offer?
Python is an interpreted general-purpose programming language best known for its high-level syntax. It can be used to build many different kinds of applications with the help of the right libraries. Furthermore, Python allows object-oriented programming and boasts features such as automatic memory management.
These qualities make the language ideal for building apps that solve real-world problems.
Python offers two main benefits:
- Python has a syntax that is easy to read and understand, making it easy to learn and debug. The simplicity helps reduce the cost of program maintenance for businesses. Additionally, developers can use Python for scripting purposes, and the third-party package support gives developers the flexibility to reuse code.
- Python is dynamically typed, which coupled with the high-level data structures, make it the go-to language for rapid application development.
#2 What does "dynamically typed" mean?
In programming, "typing" refers to type-checking. Type checking is the process of ensuring that data types are compatible with each other for the operation that the developer wants to perform.
Python is a strongly typed language, which means code such as:
Will throw a type error. The 1 in the code is a string, whereas the 2 is a number, and Python does not implicitly convert data types. In other words, strongly typed languages do not allow type coercion.
Type checking is done in two stages:
- Static: the data types are checked before execution of the program.
- Dynamic: the data types are checked during the execution of the program.
Since Python is an interpreted language, program statements are executed line after line on the fly. This makes Python a dynamically typed language.
#3 What are interpreted languages?
#4 What does PEP 8 mean, and what makes it important?
Python Enhancement Proposal (PEP) is a design document provided by the developers of the language to the community. Besides providing design information, these documents also describe new features in the language and its internal processes.
PEP 8 is a specific PEP document that outlines the style guidelines for Python. Developers contributing to the open-source community are required to follow these guidelines in their projects, making PEP 8 one of the primary guidebooks for every developer.
#5 What does "Scope" mean in Python?
The scope of an object is the block of code in which the object remains relevant. Every Python object has a scope, and the namespaces of Python uniquely identify all of the objects in a program.
Besides objects, namespaces also have a scope, and programmers can use objects in a namespace within its scope without adding a prefix. Scope is defined on different levels during the execution of the code. The different scopes are:
- The local scope, which refers to the local objects accessible in a function.
- The global scope, which refers to the objects that are accessible throughout execution.
- The module-level scope, which refers to the objects accessible in the current module.
- The outermost scope, which refers to all the built-in objects that can be used in the program. Objects in the outermost scope are searched last by Python so it can find the names referenced.
It's important to note that local scope objects can be treated as global scope objects using built-in keywords such as global.
#6 What are tuples and lists? How are they different?
In Python, both lists and tuples are sequence data types, which means they store collections of objects. Programmers can store different data types in both lists and tuples.
When programmers define lists, they use square brackets:
mylist = ["John", 7, 0.38]
On the other hand, programmers use parenthesis when defining tuples:
mytuple = ("Andy", 3, 0.29)
The primary difference between lists and tuples is that lists are mutable objects and tuples are immutable objects.
In other words, a programmer can modify a list by adding or removing data to it. However, a programmer cannot modify a tuple in any manner once it's declared.
#7 What are the data types built into Python?
Python includes several data types; however, the data types do not need to be defined when a variable of any kind is declared. That said, understanding the data types in Python is critical since ignoring the data types' compatibility with each other leads to type errors during program execution.
You can check what type of data is stored in a variable using functions such as type() and isInstance().
There are many different categories of objects in Python:
The none data type defines a null value in Python. It is designed to be used as a Boolean equality operation. It is defined using the "None" keyword.
Integers, floating-point numbers, and complex numbers are the three numeric data types available in Python. The Boolean data type is considered an integer sub-type.
|int||Stores integer literals as integers|
|float||Stores literals with decimals or exponents and floating numbers|
|complex||Stores complex numbers in A + Bi form; attributes include real and imag|
|bool||Stores true or false value|
Rational numbers and decimals can be stored using the "fractions" and "decimal" classes in the standard library, respectively.
The official Python documentation states that there are three sequence data types: lists, tuples, and range objects.
|list||It is a mutable sequence used to store a collection of elements|
|tuple||It is an immutable sequence used to store a collection of elements|
|range||It represents an immutable sequence generated during execution|
|str||It is an immutable sequence of Unicode code points used to store text|
The standard Python library also includes classes such as bytearray to store binary data.
Programmers can traverse the elements stored in sequence data types with the in and not in operators. These operators have the same precedence as value comparison operators.
Mapping objects enable programmers to map hashable values to random objects. As of 2021, there is only one mapping type: dictionary. The dictionary data type is mutable and stores a comma-separated list of key and value pairs.
A programmer would implement a dictionary like so:
a = dict(name = "Kate", age = 16, country = "Finland")
Set data types store unordered collections of hashable objects. Python currently has only two set types built-in: set and frozenset.
The set type is mutable, and programmers can use methods such as add() and remove() with it. On the other hand, as the name suggests, the frozenset data type is immutable and cannot be modified after declaration.
|set||A mutable unordered collection of distinct hashable objects|
|frozenset||Immutable collection of distinct hashable objects|
It's important to note that since frozenset is immutable, it is hashable, enabling programmers to use it as a dictionary key. Frozensets can also be used as elements of a set.
The set data type is immutable and cannot be used as a dictionary key.
A module is a built-in data type that supports attribute access, which is a special operation. Attribute access defines mymod.myobj, where mymod is the module and myobj refers to a name in the symbol table.
The symbol table of a module is stored in a special attribute of the _dict_ module. But direct assignment to this module is not possible.
These data types are the types to which a function call is applied. So, these data types include user-defined functions, generator functions, instance methods, and some select built-in functions, methods, and classes.
To understand callable types in more detail, refer to docs.python.org.
#8 What is the pass keyword?
The pass keyword is used to fill empty blocks of code that may execute during a program's runtime. In other words, the keyword represents a null operation for a block of code in a program that hasn't yet been written.
#9 What are modules and packages in the Python language? What benefits do they offer?
A module is any Python file that has a .py extension. It can comprise defined classes, functions, or variables. These files can be imported and initialized into programs using the import keyword. Programmers can also import parts of a module using the from and import keywords if they do not need to use the entire module.
The idea with modules is that they help avoid clashes between global variables in different programs.
In the same way, a package helps avoid clashes between the names of different modules. Packages are simply tools that enable the hierarchical structuring of the module namespace.
Creating a package in Python is straightforward since the system's inherent file structure is used. To create a package, programmers must simply put the modules inside a folder. The folder name is used as the package name.
To import a module from a package, programmers must append the module's name to the package name and place a dot between them.
Entire packages can be imported, too. However, doing this does not import the modules to the local namespace, making this action useless.
Benefits of Modularization
Modules and packages are Python mechanisms that enable modular programming in Python. Modularization offers several advantages:
- Simplicity: When developers work on a single module, they can put their full effort into solving a small portion of their problem. With modularization, development is easier and has fewer errors.
- Maintainability: The idea of using modules is to enforce the logical boundaries between the different domains of a problem. When modules are written in a way where interdependency is minimal, the likelihood of later modifications to one module breaking other modules is minimized.
- Reusability: Functions in one module can be reused in other parts of an application without hassle.
- Scoping: Modules have their own namespaces, which helps avoid any mix-ups between similar identifiers in different parts of the program.
#10 What are the global, private, and protected attributes?
Global variables are public variables declared with the global keyword, giving them a global scope.
Protected attributes are attributes that can be accessed and modified from outside the class it is defined in. However, a responsible developer refrains from these actions. Protected attributes have an underscore as a prefix to the identifier (for instance, "_john" is a protected attribute).
Private attributes have a double underscore behind the identifier and cannot be accessed or modified from outside the class. Trying to access or modify these identifiers results in AttributeError.
#11 What is the "self" in Python?
Programmers use self to represent an instance of the class and access the attributes and methods of a class. It's important to note that, unlike in C++, self is not a keyword in Python. However, self binds the attributes with the developer's arguments and is hence used like a keyword.
#12 What does __init__ represent?
__init__ is a constructor method that is called automatically when a new object or instance is created. Its function is to allocate memory for the object or method. Every class has a __init__ method associated with it which helps distinguish the attributes and methods of the class from the local variables that are present.
#13 What do break and continue do in Python?
Adding a break statement to the end of a loop terminates the loop and places the control at the end of the loop's body.
Like the break statement, continue is also a jump statement. However, instead of terminating the loop, the continue statement skips the current iteration of the loop. The control flows to the loop's next iteration.
#14 What is a unit test?
Unit testing involves testing the different components of a program individually. Applications typically comprise several different components working together.
However, if the application doesn't function correctly, pinpointing which part of the application is causing the issue becomes challenging. It is also possible that multiple components of the application are not functioning correctly.
A unit test is a framework utilized to test every component of an application individually. It helps identify which parts of the application may be responsible for its failure.
#15 What is the function of a docstring?
The documentation string is a multi-line string that helps developers document a segment of code. A docstring describes how a method works.
#16 What is slicing?
To slice means to take away parts of something. Slicing is used to remove parts of lists. The syntax for slicing is [start : stop : step]. "start" defines the start point of where a list must be sliced. "stop" is the index of the final element to be sliced. The "step" value defines the number of steps to jump.
Python allows slicing in lists, strings, arrays, and tuples.
#17 How are arrays different from lists in Python?
Arrays are collections of the same type of data and consume much less memory than lists do.
Lists are collections of different types of data. These data types consume a lot of memory.
Python Interview Questions for Seasoned Developers
#18 How does Python manage memory?
The Python Memory Manager handles the memory management in Python. This component allocates memory in the form of a private heap space that is reserved just for Python.
In other words, all the objects are stored in this private heap. While the data is inaccessible, there are some API functions that programmers can use to work with the private heap space.
In addition to the PMM, Python has built-in garbage collection features to keep the memory free for the private heap space.
#19 What are namespaces, and why are they used?
Namespaces are dictionaries with "name as key" mapped to "object as value," helping ensure that the object names in the program are identified as unique. Namespaces are the components that allow Python developers to use objects without any conflict.
Since namespaces are essentially dictionaries, multiple namespaces can map the same names to different objects. Namespaces can be classified into three types:
- Local namespace: It is temporarily created for function calls and is cleared by Python when the function returns an output. As the name suggests, it includes the local names that are inside the function.
- Global namespace: It is created when a program imports a package and the package is in use until the end of execution. It contains the names of the packages or modules that are in use in a given project.
- Built-in namespace: This namespace includes the names of functions that are built into Python. It also includes the names of all kinds of exceptions.
Namespaces have lifecycles that depend on the scope of the objects they are associated with. When the scope of an object ends, the lifecycle of the corresponding namespace also ends.
For this reason, accessing inner namespace objects from an outer namespace is not possible in Python.
#20 What is scope resolution?
A program may have two different objects with the same name and scope but with the objects functioning differently. Scope resolution is the process of determining the order in which the namespaces will be checked. The process enables Python to distinguish between seemingly similar objects easily.
A good example of when Python uses scope resolution is when it must distinguish between the two similarly named functions in the "math" and "cmath" modules.
#21 What is the use of decorators in Python?
A decorator function is a Python function that adds functionality to existing functions in a program without changing the function's structure. These functions are called in a bottom-up fashion.
What makes decorator functions so useful is that besides making a function more useful, they can also accept arguments for functions and modify the arguments before passing them to the function.
This is achieved by using inner nested functions to encapsulate the data and ensure that the decorator function doesn't appear globally.
#22 What is lambda, and what's its use?
In Python, lambda is an anonymous function that can accept a limitless number of arguments. However, this function can only have one expression.
Developers use the lambda function in circumstances that require an anonymous function for a short period. These functions can either be assigned to a variable or wrapped inside another function.
#23 Explain how to copy an object in Python
The assignment statement in Python does not make a copy of objects. It works by binding the existing object to the name of the target variable.
Developers can create a copy of an object using the copy module. The copy module enables programmers to copy an object in two different ways:
- Shallow copy: It creates a bitwise copy of the object that has the same values as the original. If any of the values reference other objects, the reference addresses for those objects are copied.
- Deep copy: It copies all the values from the source object to the target object in a recursive manner. The objects referenced by the source object are also duplicated.
#24 How are the range and xrange functions different?
Functionally, the range() and xrange() functions are similar since they both generate a sequence of integers. However, the range() function returns a list, and the xrange() function outputs an xrange object.
In other words, the xrange() function does not generate a static list but instead generates values on the fly. For this reason, xrange() functions are typically used with object-type generators. This technique of using generators and the xrange() function together is called "yielding."
The yielding technique is invaluable in applications that run on limited memory. Running the range() function can take up too much memory and lead to a "Memory Error."
It's important to note that xrange() is deprecated in all versions of Python 3. In Python 3, range() has the same functionality as xrange(). On the other hand, developers still prefer to use xrange() over range() in Python 2.x.
#25 Define pickling and unpickling
The standard Python library comes with serialization built-in. The process of serialization involves transforming an object into a storable format. This is done to deserialize the object later to obtain the original object.
The process of serialization is also called pickling. In this process, any object can be serialized into a byte stream and dumped as a file in the memory. This is done using the pickle.dump() function.
The process is fast, but Python compromises on compression in this process. In other words, pickle objects can be compressed further.
The biggest advantages of the pickle module are that it keeps track of the serialized objects and that pickled objects are portable across Python versions.
Unpickling is the inverse of pickling and deserializes the byte stream to reassimilate an object and load it into memory. It is carried out using the pickle.load() function.
#26 What is a generator in Python?
A generator is a function that returns an iterable collection of items one after another. These functions are typically used to create iterators, but rather than using the return keywords, generators use the yield keyword to return a generator object.
#27 What is PYTHONPATH?
It is an environment variable that programmers must set up to add additional directories. Python will look for packages and modules in these directories. The PYTHONPATH environment variable is especially helpful because it enables programmers to maintain Python libraries outside of the global default location.
#28 What are the help() and dir() functions?
Running the help() function displays the documentation of modules, classes, methods, keywords, etc. If a programmer does not pass any parameters to the function, an interactive help utility appears on the console.
The dir() function returns a list of valid methods and attributes associated with the object it is called upon. This function behaves differently with different objects since it tries to generate the most relevant data and not the complete information.
When used on library objects or modules, the function returns all of the attributes in the module. When used on class objects, it returns a list of all the base and valid attributes. Lastly, if no parameters are passed, the function returns the attributes in the current scope.
#29 How are .py files different from .pyc files?
.py and .pyc files store programs in completely different formats. While .py files have the source code of a program, .pyc files store the program's bytecode. Bytecode is generated when a .py file is compiled. .pyc files are only generated for the files that you import. These aren't generated for all the files you run.
Before any program is executed, the Python interpreter checks whether a compiled file is available. If a .pyc file is present, it is executed. But if it isn't present, Python looks for a .py file and executes it.
In simple words, a .pyc file will save a programmer's compilation time.
#30 Explain the process of interpretation
Python is neither interpreted nor compiled since interpretation and compilation are both aspects of implementation. For this reason, Python is considered a bytecode-interpreted language.
Python programs are stored as .py files, and the programs are compiled to produce instructions called "bytecode" for the virtual machine to process. This bytecode is stored as .pyc files.
Python interpreters are implementations of virtual machines. Typically, bytecode is interpreted by CPython (official interpreter) or the JIT compiler.
#31 What is pass by value and pass by reference?
Pass by value and pass by reference are the two different methods of passing arguments.
The pass by value method involves passing a copy of the object. This means if the copied object is changed, the original item will remain unaffected.
On the other hand, pass by reference involves passing a reference to the object as an argument. If the new object is modified, the original object will also change. Python passes arguments by reference.
#32 Define iterators
An iterator is an object that stores its state (where it is in the iteration) in itself. The object is initialized by the __iter__() method and the __next__() method returns the next item in the sequence. When the __next__() function reaches the end of the iterator, it throws the StopIteration exception.
#33 How are files deleted in Python?
The os.remove() function provides the simplest way to delete a Python file:
import os os.remove("XYZFile.csv") print("File Deleted")
The split() function splits a string according to the delimiter to a list of strings. The join() function is the inverse of the split() function, joining a list of strings according to the delimiter and returning a single string.#34 What are the split() and join() functions?
#35 How is *args different from **kwargs?
"*args" is a special syntax used during function definition to pass variable-length arguments. The asterisk represents the variable length in the syntax, and "args" is used conventionally.
"**kwargs" is also a special syntax; however, it is different from *args. It is used to pass variable-length keyworded arguments during the function definition. Keyworded arguments are variables that have names when they are passed to functions.
This syntax is actually a dictionary of variable names and their respective values. The "kwargs" bit is used conventionally, but programmers can use any other name.
#36 What is the use of negative indexes?
The indexes from the end of a list, tuple, or string are called negative indexes. These are used to fetch elements from the end of a list, string, or tuple. "Arr[-1]" represents the last element in an array, "Arr[-2]" is the second last element, and so on.
Python Object Oriented Programming Interview Questions
#37 Create a class and explain how it works
The keyword "class" creates a class in Python, which can then be used to create objects, access name attributes, and create and use methods.
class Pet: def __init__(self, name, age): self.name = name self.age = age p1 = Pet("Snowy", 3) print(p1.name) print(p1.age)
#38 What is inheritance in Python?
Inheritance enables one class to access all the methods and attributes of another class and is one of the features that make Python code easy to reuse.
Inheritance removes the need for developers to repeatedly copy and use chunks of code in applications, making programming more sophisticated and purposeful.
A class that inherits from another class is called the derived class or the child class. On the other hand, the class from which a child class inherits attributes and methods is called a parent or super class.
In Python, inheritance is of many different kinds:
- Single: In single inheritance, one parent class provides member access to one child class.
- Multi-level: In this kind of inheritance, the members of a parent class X are inherited by a child class Y. Then, a derived class Z inherits members from class Y. In other words, X is the grandfather of Z, and Y serves as an intermediatory class.
- Multiple: In this type of inheritance, one child class inherits members from more than one super class. All the members of the parent classes are inherited by the derived class.
- Hierarchical: When one parent class provides access to its members to several child classes, it is known as hierarchical inheritance.
#39 How are access specifiers used?
In Python, the access specifiers such as public, private, and protected are not implemented directly. The access limits of a variable are defined by placing a single or a double underscore before a variable's name. Python recognizes them as public variables by default if there are no underscores before a variable's name.
#40 Can a programmer call a parent class without creating an instance?
If the base class is a static method or is instantiated by another child class, the parent class can be called without instance creation.
#41 What is an empty class?
A class without any defined members is an empty class. The pass keyword is used to define this kind of class, and objects for an empty class can be created outside the class.
#42 How are new and override modifiers different from each other?
The new modifier instructs the compiler to make use of the new implementation instead of the base class function. Override is helpful when programmers want to override a base class function inside a child class.
#43 What is finalize?
Finalize is a built-in method that frees up unmanaged resources and cleans up Python before invoking the garbage collection method. It is one of the most useful methods for memory management.
#44 How to check if a given class is a child class?
Python offers a method in the standard library to help programmers determine whether a class is a child class or not. The issubclass() method makes it easy to tell if a class is a child class of another child.
It is also possible to check whether an object is an instance of a class using the isinstance() method built into Python.
Python Pandas Interview Questions
#45 What is pandas?
It is an open-source Python library that makes high-performance data manipulation more manageable to pull off. The name of this library comes from "Panel Data," which has multidimensional data. Wes McKinney first released Pandas in 2008, and it gained popularity because of its applications in data analysis.
Programmers can perform all five steps of data analysis using the Pandas library.
#46 What is the Pandas dataframe?
Dataframes are 2D tabular structures that are mutable. These are used to represent data with rows and columns. You can create a dataframe using the pandas library using the following syntax:
import pandas as pd dataframe = pd.DataFrame(data, index, columns, dtype)
data represents forms such as series, lists, map, dict, etc.Here,
- index is an optional argument representing the index of row labels
- columns is also an optional argument, but it represents column labels
- dtype is optional and represents the data type of every column
#47 How to combine pandas dataframes?
There are three easy ways to combine dataframes:
- Append(): The append() method stacks the dataframes horizontally
- Concat(): This method stacks the dataframes vertically. It works best when the dataframes have the same columns and similar fields.
- Join(): It extracts data from different dataframes that have one or more columns in common.
#48 How to determine if values are missing in a dataframe?
The isnull() and isna() methods are helpful in identifying whether a dataframe is missing any values. The missing values can be replaced with a 0 or the mean value of the column.
#49 What is reindexing?
The process of fitting a dataframe into a new index, optionally with some filling logic, is called reindexing. When a value is missing from the previous index, "NaN" or "NA" is placed in that location.
If the new index is equivalent to the old one, no objects are returned. However, if the new index is different from the original, a new object is returned.
The copy value is false and is typically used to change the index of rows and columns in a dataframe.
#50 How to delete rows, columns, and indices from dataframes?
The del df.index.name statement removes an index by name. On the other hand, the drop() method is useful to delete a row or column.
Programmers pass the axis argument to the drop method. If the value is 0, the method deletes the row. But if the value is 1, the method drops the column.
Setting the inplace value to True makes it possible to delete rows or columns in place and complete the task without reassignment. Duplicates can be easily removed from dataframes with the drop_duplicates() method.
#51 Can the Pandas library recognize dates when importing data from various sources?
The library can recognize the dates but not automatically. First, programmers must add the parse_dates argument when reading the data from the sources. If we read data from a CSV file, it may have different date-time formats that the Pandas library cannot work with.
In such cases, the library provides programmers the flexibility of creating a custom parser. The parser can be made without much hassle using lambda functions.
Numpy Interview Questions
#52 What is NumPy?
NumPy is among the most popular Python-based packages, and it is considered very useful since it is used for processing arrays. The library is easy to use and open-source and features optimized tools that make it possible to perform N-dimensional array processing at outstanding speeds.
The library is explicitly designed to work with complex arrays and perform statistical, algebraic, and trigonometric computations. For this reason, the library is most commonly used to perform scientific computations and broadcasting functions.
In addition to helping perform all the aforementioned computations, with NumPy, programmers can perform:
- Searching, sorting, and counting
- Matrix operations
- Copying and viewing arrays
- Bitwise operations
#53 Are NumPy arrays better than lists?
Python lists are efficient data structures that enable programmers to perform a range of different functions. However, lists also have some limitations when it comes to computing vectorized operations. These operations involve carrying out element-wise addition and multiplication.
Python lists do not work unless they have information about the data type of every element. This need for information results in overhead since type dispatching code runs every time an operation is performed on any element in the list.
NumPy arrays handle these limitations of Python lists, making them ideal for use when computing vectorized operations. NumPy arrays are almost 30 times faster than Python lists since their homogeneous nature allows them to be packed densely into the computer's memory.
For this reason, freeing up memory when NumPy arrays are used is also faster than freeing up memory when lists are used.
#54 How to load data from a text file efficiently?
The numpy.loadtxt() method can automatically read a file's header and footer. It also reads the comments if any are present in the file.
The loadtxt() method is known for being efficient. When it makes slow progress, programmers typically change the format of the file to a CSV file help Python load data more efficiently.
There are many alternatives to this method that are used depending on the NumPy version.
The method supports the following file formats:
- Text: These are large but portable and human-readable files. Generally, these are slow to load data from.
- Raw binary: Non-portable files with no metadata, but data loading is fast.
- Pickle: These files are portable but slower than CSV and binary files. The performance depends on the NumPy version.
- HDF5: Stands for "High-Powered Kitchen Sink." This file format supports both PyTables and H5PY formats.
- .npy: It is NumPy's native binary format. It's recognized for its simplicity, efficiency, and portability.
#55 How to load CSV data into an array using NumPy?
The genfromtxt() method makes it easy to load CSV data into arrays. However, the delimiter must be set to a comma.
from numpy import genfromtxt csv_data = genfromtxt(‘example_file.csv', delimiter=',')
#56 How to reverse a NumPy array with one line?
A NumPy array can easily be reversed using the slicing syntax and the result stored in another array.
reversed_array = arr[::-1]
Python Libraries Interview Questions
#57 How are packages different from modules in Python?
In Python, a module is a single file that can import other modules (files) as objects. In contrast, a package is a folder or a directory that contains various sub-packages and modules.
Programmers create Python modules by saving a file with the .py extension. These files have classes and methods that can be reused across modules.
#58 What are the most useful Python modules?
Modules are files with Python code in them saved with .py extensions, and these can contain variables, functions, and classes. The most useful built-in modules include:
#59 How to generate random numbers?
The random module comes in the standard Python library and allows programmers to generate random numbers. First, the module is imported, and next, the random() method is called. The method generates a random float value between 0 and 1.
import random print(random.random())
The module can also be used to generate random numbers between specified ranges. Putting the beginning, end, and step of some range in the randrang() method will generate a random number within that range.
import random print(random.randrange(5,100,2))
#60 What is the difference between pickling and unpickling?
The pickling process converts Python objects into binary, and the unpickling process converts binary form data into objects.
Pickled objects aid in storing disks and external memory locations. On the other hand, unpickled objects retrieve the data as objects that can be worked with in Python.
The pickle module facilitates both pickling and unpicking in Python. The pickle.dump() method dumps Python objects into memory, and the data is unpickled using the pickle.load() method.
#61 What is GIL?
The Global Interpreter Lock is a mutex (a locking mechanism) that aids in limiting access to Python objects. The GIL also helps ensure proper thread synchronization and avoids deadlocks.
The GIL is the primary component in Python that enables multitasking. We can understand how it does this with an example. Let's assume there are three threads in a system.
The GIL is acquired by the threads one at a time. When I/O operations are complete, the GIL is released by the first thread and acquired by another thread. This cycle continues until all the threads have completed execution.
Threads that do not have the GIL at any point in the process continue in a waiting state. Execution is only done with the GIL is acquired.
#62 What is PIP?
The Python Installer Package is a command-line tool used to install Python modules. Its seamless interface makes installing various modules uncomplicated.
The tool searches for the package you want to install all across the internet and, when found, installs it into Python's working directory. No user interaction is needed through this process.
#63 What tools can help identify bugs and perform the static analysis?
There are many tools that you can use to find bugs in Python code, with PyChecker being many programmer's go-to option. When PyChecker finds errors, it raises an alert for the issues and points out the error's complexity.
Pylint is a popular linting tool that checks modules for adherence to coding standards. The tool supports several plugins that enable custom features to meet a developer's needs.
#64 What is the main function?
The "main" function is considered to be the point in the program where execution begins across programming languages. However, in Python, the interpreter interprets files line-by-line and does not explicitly provide a main() function.
That said, the execution of a main() function can be easily simulated in Python. The idea is to define a main() function using the __name__ property. The __name__ variable is built into Python and points to the name of the current module.
#65 What is Flask?
Flask is a Python microframework which uses Jinja2 and Werkzeug as dependencies. Flask offers some advantages that other frameworks do not offer:
- It doesn't use as many dependencies on external libraries
- The lack of external dependency makes the microframework exceptionally lightweight. It also results in fewer security patches needing to be released.
- Features a built-in development server and a high-performance debugger
#66 All the memory isn't deallocated when a developer exits Python. Why?
Python has an effective clean-up mechanism that runs automatically when a user exits Python. This mechanism tries to deallocate or destroy all the objects.
But some Python modules have circular references to objects. Sometimes, the objects referenced from global namespaces are not deallocated, too, since deallocating or destroying these portions reserved by the C library is not possible.
#67 Is Flask better than Django?
Both Flask and Django map the URLs typed in browsers to functions; however, there are some key differences between the two frameworks.
Flask is easier to use but does not do much legwork for the user. So, Flask users must specify the details for Flask manually.
On the other hand, Django has pre-written code that the users can analyze and use. This removes a lot of the work programmers need to do to use the framework.
While both Flask and Django are equally useful, what a developer chooses comes down to their preference of the kind of work they like to do.
#68 How are Flask, Pyramid, and Django different from each other?
Flask is a ready-to-use microframework for small applications. It uses external libraries.
Pyramid is a heavily-configurable tool designed for large applications. It gives users a choice of tools to use and also provides the flexibility to choose the database, templating style, etc.
Django is built for large applications and comes with an ORM which makes transferring data from relational databases and application models possible.
#69 What is the dogpile effect?
It is an event where the cache expires, and websites receive multiple requests by the client simultaneously. The event can be avoided by using a semaphore lock.
Going through the questions in this post will not be enough to get through an interview. You must practice answering these questions and also refine your programming skills daily. Cracking any Python interview will not be too challenging if you stay focused.