100+ Python Developer Interview Questions
100+ Python Developer Interview Questions
for Freshers
LIST TUPLES
Lists are mutable i.e., they can be edited. Tuples are immutable, meaning they
Lists are slower than tuples. Tuples are faster than lists.
Syntax: list_1 = [10, ‘Chelsea’, 20] Syntax: tup_1 = (10, ‘Chelsea’, 20)
its variants, Python does not need to be compiled before it is run. Other
● Python is dynamically typed, this means that you don’t need to state the types of
variables when you declare them or anything like that. You can do things like
● Python is well suited to object oriented programming in that it allows the definition
of classes along with composition and inheritance. Python does not have access
● In Python, functions are first-class objects. This means that they can be assigned
to variables, returned from other functions and passed into functions. Classes are
● Writing Python code is quick but running it is often slower than compiled
bottlenecks can be optimized away and often are. The numpy package is a good
example of this, it’s really quite quick because a lot of the number-crunching it
modeling, big data applications and many more. It’s also often used as “glue”
code to get other languages and components to play nice. Learn more about Big
Data and its applications from the Azure data engineer training course.
Q5.What is pep 8?
Ans: PEP stands for Python Enhancement Proposal. It is a set of rules that specify how
to format Python code for maximum readability.
the code line by line and stops if an error occurs in any line.
3. Dynamically typed– the developer does not assign data types to variables
source.
5. Extensive support for libraries– Python has vast libraries that contain
almost any function needed. It also further provides the facility to import
6. Portable– Python programs can run on any platform without requiring any
change.
1. Built-in namespace– These namespaces contain all the built-in objects in python
2. Global namespace– These are namespaces for all the objects created at the
function.
Ans: Decorators are used to add some design patterns to a function without changing
its structure. Decorators generally are defined before the function they are enhancing.
To apply a decorator we first define the decorator function. Then we write the function it
is applied to and simply add the decorator function above the function it has to be
applied to. For this, we use the @ symbol before the decorator.
Ans: Dictionary and list comprehensions are just another concise way to define
dictionaries and lists.
14
2[0,1,2,3,4]
1[0: 2, 1: 3, 2: 4, 3: 5, 4: 6]
Numbers– They include integers, floating-point numbers, and complex numbers. eg. 1,
7.9,3+4i
List– An ordered sequence of items is called a list. The elements of a list may belong to
different data types. Eg. [5,’market’,2.4]
Tuple– It is also an ordered sequence of elements. Unlike lists , tuples are immutable,
which means they can’t be changed. Eg. (3,’tool’,1)
String– A sequence of characters is called a string. They are declared within single or
double-quotes. Eg. “Sana”, ‘She is going to the market’, etc.
Set– Sets are a collection of unique items that are not in order. Eg. {7,6,8}
Dictionary– A dictionary stores values in key and value pairs where each value can be
accessed through its key. The order of items is not important. Eg.
{1:’apple’,2:’mango}
Ans: The .py files are the python source code files. While the .pyc files contain the
bytecode of the python files. .pyc files are created when the code is imported from some
other source. The interpreter converts the source .py files to .pyc files which helps by
saving time. You can get a better understanding with the Data engineering course in
Washington.
Ans: Slicing is used to access parts of sequences like lists, tuples, and strings. The
syntax of slicing is-[start:end:step]. The step can be omitted as well. When we write
[start:end] this returns all the elements of the sequence from the start (inclusive) till
the end-1 element. If the start or end element is negative i, it means the ith element
from the end. The step indicates the jump or how many elements have to be skipped.
Eg. if there is a list- [1,2,3,4,5,6,7,8]. Then [-1:2:2] will return elements starting
from the last element till the third element by printing every second element.i.e.
[8,6,4].
Ans: Keywords in python are reserved words that have special meaning.They are
generally used to define type of variables. Keywords cannot be used for variable or
function names. There are following 33 keywords in python-
● And
● Or
● Not
● If
● Elif
● Else
● For
● While
● Break
● As
● Def
● Lambda
● Pass
● Return
● True
● False
● Try
● With
● Assert
● Class
● Continue
● Del
● Except
● Finally
● From
● Global
● Import
● In
● Is
● None
● Nonlocal
● Raise
● Yield
Ans: A literal in python source code represents a fixed value for primitive data types.
There are 5 types of literals in python-
1. String literals– A string literal is created by assigning some text enclosed in single
or double quotes to a variable. To create multiline literals, assign the multiline text
3. Numeric literals include numeric values that can be either integer, floating point
The concat() function is used to concatenate two dataframes. Its syntax is-
pd.concat([dataframe1, dataframe2]).
Dataframes are joined together on a common column called a key. When we combine
all the rows in dataframe it is union and the join used is outer join. While, when we
combine the common rows or intersection, the join used is the inner join. Its syntax is-
pd.concat([dataframe1, dataframe2], axis=’axis’, join=’type_of_join)
ins, etc.
● Deprecated functions and commands such as deprecated parser and symbol
Python objects and data structures are located in a private heap. The
programmer does not have access to this private heap. The python interpreter
2. The allocation of heap space for Python objects is done by Python’s memory
manager. The core API gives access to some tools for the programmer to code.
3. Python also has an inbuilt garbage collector, which recycles all the unused
Q20. What are python modules? Name some commonly used built-in
modules in Python?
Ans: Python modules are files containing Python code. This code can either be
functions classes or variables. A Python module is a .py file containing executable code.
● os
● sys
● math
● random
● data time
● JSON
Variables declared outside a function or in global space are called global variables.
These variables can be accessed by any function in the program.
Local Variables:
Any variable declared inside a function is known as a local variable. This variable is
present in the local space and not in the global space.
Example:
1a=2
2def add():
3b=3
4c=a+b
5print(c)
6add()
Output: 5
When you try to access the local variable outside the function add(), it will throw an
error.
list() – This function is used to convert any data type to a list type.
dict() – This function is used to convert a tuple of order (key, value) into a dictionary.
● After this, install it on your PC. Look for the location where PYTHON has been
cmd python.
● Then go to advanced system settings and add a new variable and name it as
● Look for the path variable, select its value and select ‘edit’.
● Add a semicolon towards the end of the value if it’s not present and then type
%PYTHON_HOME%
2My_Array=arr.array('i',[1,2,3,4])
3My_list=[1,'abc',1.20]
4print(My_Array)
5print(My_list)
Output:
Example:
1def Newfunc():
Q28.What is __init__?
Ans: __init__ is a method or constructor in Python. This method is automatically called
to allocate memory when a new object/ instance of a class is created. All classes have
the __init__ method.
3self.name = name
4self.age = age
5self.salary = 20000
9print(E1.name)
10print(E1.age)
11print(E1.salary)
Output:
XYZ
23
20000
Example:
2print(a(5, 6))
Output: 11
Q30. What is self in Python?
Ans: Self is an instance or an object of a class. In Python, this is explicitly included as
the first parameter. However, this is not the case in Java where it’s optional. It helps to
differentiate between the methods and attributes of a class with local variables.
The self variable in the init method refers to the newly created object while in other
methods, it refers to the object whose method was called.
Break Allows loop termination when some condition is met and the
Continue Allows skipping some part of a loop when some specific condition
Pass Used when you need some block of code syntactically, but you
For example:
2My_Array=arr.array('i',[1,2,3,4,5])
3My_Array[::-1]
[::-1] reprints a reversed copy of ordered data structures such as an array or a list. the
Q33. How can you randomize the items of a list in place in Python?
Ans: Consider the example shown below:
3shuffle(x)
4print(x)
1import random
2random.random
The statement random.random() method return the floating-point number that is in the
range of [0, 1). The function generates random float numbers. The methods that are
used with the random class are the bound methods of the hidden instances. The
instances of the Random can be done to show the multi-threading programs that
creates a different instance of individual threads. The other random generators that are
used in this are:
1. randrange(a, b): it chooses an integer and define the range in-between [a, b). It
returns the elements by selecting it randomly from the range that is specified. It
2. uniform(a, b): it chooses a floating point number that is defined in the range of
a mean and the sdev is a sigma that is used for standard deviation.
4. The Random class that is used and instantiated creates independent multiple
This means that xrange doesn’t actually generate a static list at run-time like range
does. It creates the values as you need them with a special technique called yielding.
This technique is used with a type of object known as generators. That means that if
you have a really gigantic range you’d like to generate a list for, say one billion, xrange
is the function to use.
This is especially true if you have a really memory sensitive system such as a cell
phone that you are working with, as range will use as much memory as it can to create
your array of integers, which can result in a Memory Error and crash your program. It’s a
memory hungry beast.
Example:
string already consists of a capital letter at the beginning, then, it returns the original
string.
Example:
1stg='ABCD'
2print(stg.lower())
Output: abcd
multiple lines. All you need to do is hold the ctrl key and left click in every place
wherever you want to include a # character and type a # just once. This will comment all
the lines where you introduced your cursor.
Example:
1"""
4"""
5x=8
6y=4
7z=x/y
8print(z)
Output: 2.0
is: returns true when 2 operands are true (Example: “a” is ‘a’)
1. Help() function: The help() function is used to display the documentation string
and also facilitates you to see the help related to modules, keywords, attributes,
etc.
2. Dir() function: The dir() function is used to display the defined symbols.
Q46. Whenever Python exits, why isn’t all the memory de-allocated?
Ans:
1. Whenever Python exits, especially those Python modules which are having
circular references to other objects or the objects that are referenced from the
C library.
3. On exit, because of having its own efficient clean up mechanism, Python would
The following example contains some keys. Country, Capital & PM. Their corresponding
values are India, Delhi and Modi respectively.
1dict={'Country':'India','Capital':'Delhi','PM':'Modi'}
1print dict[Country]
Output:India
1print dict[Capital]
Output:Delhi
1print dict[PM]
Output:Modi
Syntax:
Example:
The expression gets evaluated like if x<y else y, in this case if x<y is true then the value
is returned as big=x and if it is incorrect then big=y will be sent as a result.
Q49. What does this mean: *args, **kwargs? And why would we use it?
Ans: We use *args when we aren’t sure how many arguments are going to be passed to
a function, or if we want to pass a stored list or tuple of arguments to a function.
**kwargs is used when we don’t know how many keyword arguments will be passed to
a function, or it can be used to pass the values of a dictionary as keyword arguments.
The identifiers args and kwargs are a convention, you could also use *bob and **billy
but that would not be wise.
1stg='ABCD'
2len(stg)
Output:4
● sub() – finds all substrings where the regex pattern matches and then replace
● subn() – it is similar to sub() and also returns the new string along with the no. of
replacements.
Q52. What are negative indexes and why are they used?
Ans: The sequences in Python are indexed and it consists of the positive as well as
negative numbers. The numbers that are positive uses ‘0’ that is uses as first index and
‘1’ as the second index and the process goes on like that.
The index for the negative number starts from ‘-1’ that represents the last index in the
sequence and ‘-2’ as the penultimate index and the sequence carries forward like the
positive number.
The negative index is used to remove any new-line spaces from the string and allow the
string to except the last character that is given as S[:-1]. The negative index is also used
to show the index to represent the string in correct order.
Example:
1import os
2os.remove("xyz.txt")
● Integers
● Floating-point
● Complex numbers
● Strings
● Boolean
● Built-in functions
Q56. What advantages do NumPy arrays offer over (nested) Python lists?
Ans:
2. They have certain limitations: they don’t support “vectorized” operations like
elementwise addition and multiplication, and the fact that they can contain
objects of differing types mean that Python must store type information for every
element, and must execute type dispatching code when operating on each
element.
3. NumPy is not just more efficient; it is also more convenient. You get a lot of
vector and matrix operations for free, which sometimes allow one to avoid
4. NumPy array is faster and You get a lot built in with NumPy, FFTs, convolutions,
Example:
2a.append(3.4)
3print(a)
4a.extend([4.5,6.3,6.8])
5print(a)
6a.insert(2,3.8)
7print(a)
Output:
Example:
2print(a.pop())
3print(a.pop(3))
4a.remove(1.1)
5print(a)
Output:
4.6
3.1
Deep copy is used to store the values that are already copied. Deep copy doesn’t copy
the reference pointers to the objects. It makes the reference to an object and the new
object that is pointed by some other object gets stored. The changes made in the
original copy won’t affect any other copy that uses the object. Deep copy makes
execution of the program slower due to making certain copies for each object that is
been called.
your code up, then it’s usually not a good idea to use it.
2. Python has a construct called the Global Interpreter Lock (GIL). The GIL makes
sure that only one of your ‘threads’ can execute at any one time. A thread
acquires the GIL, does a little work, then passes the GIL onto the next thread.
3. This happens very quickly so to the human eye it may seem like your threads are
executing in parallel, but they are really just taking turns using the same CPU
core.
4. All this GIL passing adds overhead to execution. This means that if you want to
make your code run faster then using the threading package often isn’t a good
idea.
1. Create a file with any name and in any language that is supported by the
2. Place this file in the Modules/ directory of the distribution which is getting used.
3. Add a line in the file Setup.local that is present in the Modules/ directory.
5. After a successful run of this rebuild the interpreter by using the make command
6. If the file is changed then run rebuildMakefile by using the command as ‘make
Makefile’.
Example:
1a="pythons python"
2print(a.split())
Example:
Next, in this Python Interview Questions blog, let’s have a look at Object Oriented
Concepts in Python.
These Python Interview Questions and Answers will help you prepare for Python job
interviews. Start your preparation by going through the most frequently asked questions
on Python.
super class.
child classes
4. Multiple inheritance – a derived class is inherited from more than one base class.
Example:
1class Employee:
3self.name = name
4E1=Employee("abc")
5print(E1.name)
Output: abc
1# m.py
2class MyClass:
3def f(self):
4print "f()"
2def monkey_f(self):
3print "monkey_f()"
5m.MyClass.f = monkey_f
6obj = m.MyClass()
7obj.f()
monkey_f()
As we can see, we did make some changes in the behavior of f() in MyClass using the
function we defined, monkey_f(), outside of the module m.
Ans: Python does not deprive access to an instance variable or function. Python lays
down the concept of prefixing the name of the variable, function or method with a single
or double underscore to imitate the behavior of protected and private access specifiers.
Ans: An empty class is a class that does not have any code defined within its block. It
can be created using the pass keyword. However, you can create objects of this class
outside the class itself. IN PYTHON THE PASS command does nothing when its
For example-
1class a:
2 pass
3obj=a()
4obj.name="xyz"
5print("Name = ",obj.name)
Output:
Name = xyz
any parameters.
Next, let us have a look at some Basic Python Programs in these Python Interview
Questions.
1def bs(a):
2# a = name of list
3 b=len(a)-1nbsp;
5 for x in range(b):
6 for y in range(b-x):
7 a[y]=a[y+1]
9 a=[32,5,3,6,7,54,87]
10 bs(a)
1def pyfunc(r):
2 for x in range(r):
3 print(' '*(r-x-1)+'*'*(2*x+1))
4pyfunc(9)
Output:
***
*****
*******
*********
***********
*************
***************
*****************
5if a=0:
6 print("The requested series is",f)
7else:
8 print(f,s,end=" ")
9 for x in range(2,a):
10 print(next,end=" ")
11 f=s
12 s=next
1a=int(input("enter number"))
2if a=1:
3 for x in range(2,a):
4 if(a%x)==0:
5 print("not prime")
6 break
7 else:
8 print("Prime")
9else:
10 print("not prime")
Output:
enter number 3
Prime
Q80. Write a program in Python to check if a sequence is a Palindrome.
1a=input("enter sequence")
2b=a[::-1]
3if a==b:
4 print("palindrome")
5else:
6 print("Not a Palindrome")
Output:
Q81. Write a one-liner that will count the number of capital letters in a file.
Your code should work even if the file is too big to fit in memory.
Ans: Let us first write a multiple line solution and then convert it to one-liner code.
2count = 0
3text = fh.read()
5 if character.isupper():
6count += 1
3list.sort()
4print (list)
Q83. Looking at the below code, write down the final values of A0, A1,
…An.
1A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
7print(A0,A1,A2,A3,A4,A5,A6)
vary
A1 = range(0, 10)
A2 = []
A3 = [1, 2, 3, 4, 5]
A4 = [1, 2, 3, 4, 5]
9: 81}
A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36],
A session basically allows you to remember information from one request to another. In
a flask, a session uses a signed cookie so the user can look at the session contents and
modify them. The user can modify the session if only it has the secret key
Flask.secret_key.
Flask is much simpler compared to Django but, Flask does not do a lot for you meaning
you will need to specify the details, whereas Django does a lot for you wherein you
would not need to do much work. Django consists of prewritten code, which the user will
need to analyze whereas Flask gives the users to create their own code, therefore,
making it simpler to understand the code. Technically both are equally good and both
contain their own pros and cons.
requirements. In flask, you have to use external libraries. Flask is ready to use.
● Pyramid is built for larger applications. It provides flexibility and lets the developer
use the right tools for their project. The developer can choose the database, URL
● Django can also be used for larger applications just like Pyramid. It includes an
ORM.
The developer provides the Model, the view and the template then just maps it to a URL
and Django does the magic to serve it to the user.
‘django.db.backeneds.mysql’, ‘django.db.backends.postgresql_psycopg2’,
‘django.db.backends.oracle’ and so on
● Name: The name of your database. In the case if you are using SQLite as your
database, in that case, database will be a file on your computer, Name should be
● If you are not choosing SQLite as your database then settings like Password,
Django uses SQLite as a default database, it stores data as a single file in the
filesystem. If you do have a database server—PostgreSQL, MySQL, Oracle,
MSSQL—and want to use it rather than SQLite, then use your database’s
administration tools to create a new database for your Django project. Either way, with
your (empty) database in place, all that remains is to tell Django how to use it. This is
where your project’s settings.py file comes in.
1DATABASES = {
2 'default': {
3 'ENGINE' : 'django.db.backends.sqlite3',
6}
2import datetime
4def Current_datetime(request):
5 now = datetime.datetime.now()
7 return HttpResponse(html)
So the data itself is not stored client side. This is nice from a security perspective.
1. Abstract Base Classes: This style is used when you only want parent’s class to
hold information that you don’t want to type out for each child model.
model and need each model to have its own database table.
3. Proxy models: You can use this model, If you only want to modify the Python
1import urllib.request
2urllib.request.urlretrieve("URL", "local-filename.jpg")
Q94. How can you Get the Google cache age of any URL or web page?
Ans: Use the following URL format:
http://webcache.googleusercontent.com/search?q=cache:URLGOESHERE
Be sure to replace “URLGOESHERE” with the proper web address of the page or site
whose cache you want to retrieve and see the time for. For example, to check the
Google Webcache age of pythons.co you’d use the following URL:
http://webcache.googleusercontent.com/search?q=cache:pythons.co
Q95. You are required to scrap data from IMDb top 250 movies page. It
should only have fields movie name, year, and rating.
Ans: We will use the following lines of code:
3import requests
4import sys
6url = '<a
href="http://www.imdb.com/chart/top">http://www.imdb.com/chart
7/top</a>'
8response = requests.get(url)
9soup = BeautifulSoup(response.text)
10tr = soup.findChildren("tr")
11tr = iter(tr)
12next(tr)
13
print(row)
The above code will help scrap data from IMDb’s top 250 list
1. Less Memory
2. Fast
3. Convenient
For more information on these parameters, you can refer to this section – Numpy Vs
List.
Q98. How to get indices of N maximum values in a NumPy array?
Ans: We can get the indices of N maximum values in a NumPy array using the below
code:
1import numpy as np
3print(arr.argsort()[-3:][::-1])
Output
[ 4 3 1 ]
import numpy as np
1
a = np.array([1,2,3,4,5])
2
p = np.percentile(a, 50) #Returns 50th percentile, e.g.
3
median
4
print(p)
Output:3
NumPy SciPy
It refers to Numerical python. It refers to Scientific python.
It has fewer new scientific computing Most new scientific computing features
It contains less linear algebra functions. It has more fully-featured versions of the
NumPy has a faster processing speed. SciPy on the other hand has slower
computational speed.
When both of the operands are integer then python chops out the fraction part and
gives you the round off value, to get the accurate answer use floor division. For ex, 5/2
= 2.5 but both of the operands are integer so answer of this expression in python is 2.
To get the 2.5 as the answer, use floor division using //. So, 5//2 = 2.5
As Python has no concept of private variables, leading underscores are used to indicate
variables that must not be accessed from outside the class.
1try:
2 if '1' != 1:
3 raise "someError"
4 else:
6except "someError":
Q108. Suppose list1 is [2, 33, 222, 14, 25], What is list1[-1] ?
a) Error
b) None
c) 25
d) 2
Answer: c) 25
1f = None
5 if (i > 2):
6 break
8print f.closed
a) True
b) False
c) None
d) Error
Answer: a) True
The WITH statement when used with open file guarantees that the file object is closed
when the with block exits.