Python Interview Questions and Answers

1. Python Interview Questions and Answers for Intermediate
2. Python Interview Questions and Answers for Freshers
3. Python Interview Questions and Answers for OOPs Concept
4. Python Interview Questions and Answers for Coding
5. Python Interview Questions and Answers for Experienced Professionals

To convert the string into a number the built-in functions are used like int() constructor. int() is a data type that is used like int (‘1’) ==1. float() is also used to show the number in the format as float(‘1’)=1.

In this the int(string, base) function takes the parameter to convert string to number in this the process will be like int(‘0x1’,16)==16. If the base parameter is defined as 0 then it is indicated by octal and 0x indicates it as a hexadecimal number. eval() is used to convert a string into number

A lambda function is the anonymous function that can have any number of parameters but can have just one statement.

								
v = lambda p,q : p+q
print(v(6, 5))
	

[::-1] is used to reverse the order of an array or a sequence.

								
import array as arr
a=arr.array('i',[1,2,3,4])
a[::-1]			
							

[::-1] reprints the array as a reversed copy of ordered data structures such as an array or a list. The original array or list remains unchanged.

							
l = [ 'a','b','c','d' ]
l[::-1]

The sequences in python are indexed and it consists of positive as well as negative numbers. The numbers that are positive use ‘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’ which 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

• To remove any new-line spaces from the string and allow the string to except the last character that is given as S[:-1].
• To show the index to represent the string in the correct order.

							
class Employee:
   def __init__(self, employee_name):
       self.name = employee_name

 employee = Employee("John")

							
print(employee.name)
# Prints -> John

Take a look here :

Python is able to check multiple conditions at the same time which does not have to follow a particular order of operators.

Python does not use access specifiers precisely like private, public, protected, etc. However. It has the concept of imitating variables' behavior using a single (protected) or double underscore (private) as prefixed to variable names. By default, variables without prefixed underscores are public.

							
# to demonstrate access specifiers
class Employee:
   
    # protected members
    _name = None
    _age = None
    
    # private members
    __department = None
    
    # constructor
    def __init__(self, emp_name, age, department): 
         self._name = emp_name
         self._age = age
         self.__department = department
    
    # public member
    def display():
        print(self._name + " "+ self._age + " " + self.__department)							
											

By using the name of the Parent class: use name of the parent class to access attributes as shown in the example below:

							
class Parent(object):  

   # Constructor

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

 class Child(Parent): 

   # Constructor

   def __init__(self, name, age):

       Parent.name = name
       self.age = age

  def display(self)
  
       print(Parent.name, self.age)

 # Driver Code

obj = Child("ChildClassInstance", 9)
obj.display()

The global interpreter lock is used to allow the running of the thread one at a time. This is internal to the program only and used to distribute the functionality along all the virtual machines that are used. Python allows the switching between the threads to be performed by using the byte code instructions that are used to provide platform-independence.

The sys.setcheckinterval() method is used that allow the switching to occur during the implementation of the program and the instruction. This provides the understanding in the field of accounting to use the byte code implementation that makes it portable to use.

The 'main' function is considered as an entry point for the execution for a program. But in Python, this is known that the interpreter serially interprets the file line-by-line. This means that Python does not provide the 'main()' function explicitly. But this doesn't mean that it a cannot simulate the execution of 'main'.

It can do this by defining the user-defined 'main()' function and using the python file's '__name__' property. This '__name__' variable is a particular built-in variable that points to the current module's name. This can be done as shown below:

							
 print("Hi!")
if __name__ == "__main__":
 main()

The module that is used to write and read the binary data is known as struct. This module allows the functionality and with it many functionalities to be used that consists of the string class. This class contains the binary data that is in the form of numbers that gets converted in python objects for use and vice versa. The program can read or write the binary data is:

							
 import struct
f = open(file-name, "rb")
# This Open() method allows the file to get opened in binary mode to make it portable for # use.
s = f.read(8)
x, y, z = struct.unpack(">hhl", s)

The ‘>” is used to show the format string that allows the string to be converted in big-endian data form. For homogenous list of data the array module can be used that will allow the data to be kept more organized fashion.

Did you know :

Unlike Java and C++, Python does not use braces but Indentation is mandatory.

Re is a Python module developers use to execute operations that involve expression matching. In particular, it contains three modules to allow editing strings – subn(), sub(), and split().

Here are the differences between these methods:

Python has the following multi-threading tools:

• A designated multi-threading package. It’s not widely used as it slows code execution down.
• GIL (Global Interpreter Lock) constructor. It helps ensure that only one string is executed at a time. After GIL executes a string, it’ll get passed over to the next one.

Inheritance is a way for a class to pass its members (e.g. methods or attributes) to a new class. In this case, a class that contains the original data is called a super-class. The inheriting class is called a child or derived class.

• Single inheritance – a child class inherits the data passed down by one super-class.
• Multiple inheritance – a child class inherits the members of several super-classes.
• Multi-level inheritance – a derived class d1 inherits the members of a super-class b1; a child class d2 inherits the data from a base class b2.
• Hierarchical inheritance – a high number of child classes can inherit the members of one superclass.

Yes, tools like PyChecker and Pylint are used as a static analysis and linting tools, respectively. PyChecker helps find bugs in a python source code file and raises alerts for code issues and complexity. Pylint checks for a module's coding standards and supports different plugins to enable custom features to meet this requirement.

Python packages are namespaces containing multiple modules such as “os”, “sys”, “json”, “pandas” etc.

Make a Note :

As a Python Variables, it can can only begin with a letter(A-Z/a-z) or an underscore(_).

from random import shuffle

Output :
['sentence', 'This', 'will', 'shuffled', 'be', 'now']

Every time output can be random.

'xrange' and 'range' provide a way to generate a list of integers to use. The only difference is that 'range' returns a Python list object while 'xrange' returns an 'xrange' object. 'xrange' doesn't generate a static list at run-time as 'range' does. It creates the values as you need them with a unique technique called yielding.

This technique is used with a type of object known as generators. That means that if you have a vast range, you'd like to generate a list for, say, one billion, 'xrange' is the function to use.

Modules are simply Python files with a '.py' extension and can have a set of functions, classes and variables defined. They can be imported and initialised using import statements if partial functionality is required to import the requisite classes or processes.

Packages provide for hierarchical structuring of the module namespace using a '.' dot notation. As modules help avoid clashes between global and local variable names, similarly, packages can help prevent conflicts between module names. Creating a package is easy since it also uses the system's inherent file structure that exists.

Modules combined into a folder are known as packages. Importing a module or its contents from a package requires the package name as a prefix to the module's name joined by a dot.

*args is a particular parameter used in the function definition to pass arguments with a variable number of items. "*" means variable length, and "args" is a name used as a convention.

**kwargs is a special syntax used as the function definition to pass a variable-length keyword argument. It can be used just as a convention. It can also use any other name to represent "kwargs" here.

Yes, it is possible if other child classes instantiate the base class or if the base class is a static method.

List and Tuple are both ordered containers. If you want an ordered container of constant elements use tuple as tuples are immutable objects and list are mutable in nature.

• read-only mode
• write-only mode
• read-write mode
• Append mode
• By specifying the flags “r”, “w”, “rw”, “a” respectively.


• A text file can be opened in any one of the above said modes by specifying the option “t” along with “r”, “w”, “rw”, and “a”, so that the preceding modes become “rt”, “wt”, “rwt”, and “at”.


• A binary file can be opened in any one of the above said modes by specifying the option “b” along with “r”, “w”, “rw”, and “a” so that the preceding modes become “rb”, “wb”, “rwb”, “ab”.

• Dictionaries :are best suited when the data is labeled, i.e., the data is a record with field names.
• Lists are a better option to store collections of un-labeled items say all the files and subdirectories in a folder. List comprehension is used to construct lists in a natural way. Generally, the Search operation on a dictionary object is faster than searching a list object.

Both append() and extend() methods are the methods of the list. These methods are used to add the elements at the end of the list.

• append(element) – adds the given element at the end of the list which has called this method.


• extend(another-list) – adds the elements of another list at the end of the list which is called the extend method.

No, it is not, because the objects that are referenced from global namespaces of Python modules are not always deallocated when Python exits.

Check this out :

With slicing, it is easier to reverse a list from starting to end but with a step of --1.

repr() compute the “official” string representation of an object i.e. a representation that has all information about the object and str() is used to compute the “informal” string representation of an object (a representation that is useful for printing the object)

A function is called Higher Order Function if it contains other functions as a parameter or returns a function as an output i.e., the functions that operate with another function are known as Higher-order Functions.

Use = operator to create a copy of an object. It creates a new variable that shares the reference of the original object.

Array in Python can be created by importing an array module. array(data_type, value_list) is used to create an array with data type and value list specified in its arguments.

Exceptions can be handled using a try statement. The critical operation which can raise an exception is placed inside the try clause. The code that handles the exceptions is written in the except clause. We can then choose what operations to perform once we have caught the exception.

Think about that for a min :

In Python, you can declare a local variable in a function, class, or so which will be only visible in that scope. If you call it outside of that scope, then you get an ‘undefined’ error.

Instance methods need a class instance and can access the instance through self. Class methods don't need a class instance. They can't access the instance ( self ) but they have access to the class itself via cls. Static methods don't have access to cls or self.

An iterator in python is an object that is used to iterate over iterable objects like lists, tuples, dicts, and sets. The iterator object is initialized using the iter() method. It uses the next() method for iteration. Generators in Python are used to create iterators and return a traversal object. It helps in traversing all the items one at a time with the help of the keyword yield.

The exec() function executes the specified Python code. The exec() function accepts large blocks of code, unlike the eval() function which only accepts a single expression.

Python descriptors are a way to create managed attributes. Among their many advantages, managed attributes are used to protect an attribute from changes or to automatically update the values of a dependant attribute. Descriptors increase an understanding of Python and improve coding skills.

Method Resolution Order (MRO) denotes the way a programming language resolves a method or attribute. Python supports classes inheriting from other classes. The class being inherited is called the Parent or Superclass, while the class that inherits is called the Child or Subclass.

know the best part :

Python is one of the official Google languages due of its efficiency. It is advantageous with simple to use, even on large projects. YouTube is also powered by Python programming.

A metaclass in Python is a class of a class that defines how a class behaves. A class is itself an instance of a metaclass. A class in Python defines how the instance of the class will behave. In order to understand metaclasses well, one needs to have prior experience working with Python classes.

Python sequences can be index in positive and negative numbers. For positive index, 0 is the first index, 1 is the second index and so forth. For negative index, (-1) is the last index and (-2) is the second last index and so forth.

Learn here :

Function Argument Unpacking is another awesome feature of Python. Unpack a list or a dictionary as function arguments using * and ** respectively. This is commonly known as the Splat operator.

• Local variables : If a variable is assigned a new value anywhere within the function’s body, it’s assumed to be local.


• Global variables : Those variables that are only referenced inside a function are implicitly global.

To share global variables across modules within a single program, create a special module. Import the config module in all modules of your application. The module will be available as a global variable across modules.

• Python comprises of a huge standard library for most Internet platforms like Email, HTML, etc.
• Python does not require explicit memory management as the interpreter itself allocates the memory to new variables and free them automatically.
• Provides easy readability due to the use of square brackets.
• Easy-to-learn for beginners.
• Having the built-in data types saves programming time and effort from declaring variables.

Python language is an interpreted language. Python program runs directly from the source code. It converts the source code that is written by the programmer into an intermediate language, which is again translated into machine language that has to be executed.

A scope defines the hierarchical order in which the namespaces have to be searched in order to obtain the mappings of name-to-object(variables). It is a context in which variables exist and from which they are referenced. It defines the accessibility and the lifetime of a variable.

Small Stuff here :

In Python, you can declare a local variable in a function, class, or so which will be only visible in that scope. If you call it outside of that scope, then you get an ‘undefined’ error.

The isinstance() function returns True if the specified object is of the specified type, otherwise False. If the type parameter is a tuple, this function will return True if the object is one of the types in the tuple.

Python is a dynamic, high-level, free open source, and interpreted programming language. It supports object-oriented programming as well as procedural-oriented programming. In Python, we don't need to declare the type of variable because it is a dynamically typed language.

Indexing refers to an element of an iterable by its position within the iterable. The slicing operation helps in getting a subset of elements from an iterable based on their indices.

repr() compute the “official” string representation of an object (a representation that has all information about the object) and str() is used to compute the “informal” string representation of an object (a representation that is useful for printing the object).

“Typed” means the type of the variable.There are two typed languages.

• Dynamically typed language
• Statically typed language

Conclusion :

To finalize, learn Python Training in Chennai at Credo Systemz to develop the in-built knowledge with placement assistance. This Python Interview Questions and Answers for Freshers helps to strength the basic concepts of python and to practice them effectively.

							
class Parent1:
def first_parent(self):
print(‘This is first parent class’)
class Parent2:
def second_parent(self):
print(‘This is second parent class’)
class ChildClass(Parent1, Parent2):
def child_class (slef):
print(‘This is child class’)
obj = ChildClass()
obj.first_parent()
obj.second_parent()
obj.child_class()

• New Modifiers - state the compiler to run a new function and not use the one from the base class.
• Override Modifier - instructs to run the base class version of a class and not create a new one. This reduces unnecessary repetitions of writing codes.

Abstract methods are declarations of methods without proper implementation. The implementation is done when inherited into child classes and defined.

Class variables are accessible in all instances of the class. In the python class, Class variables are defined at the beginning of the class. If a class variable changes in one instance, its effect is in the class variable of the other instance. We can access class variables outside the class also, to access it use the class name and class variable name.

You know this :

Python was initially released in 1991 whereas Java was released in 1995. Thus, Python is almost 30 years old and stands strong for the future.

The new method creates the instance of a class. It will use to control the creation of a new instance of the class. It allocates memory for the object. The instance variables of an object need memory to hold it. This method will be called at the time of object creation. The new method accepts a type as the first argument and returns a new instance of that type. The new method will be used to control the creation of a new instance. The new method returns the new instance to called class.

							
class Student(): 
def __new__(cls): 
print("We are in new method") 
return super(Student, cls).__new__(cls) 

def __init__(self): 
print("We are in init method") 

student = Student() 
print(student)
)

There are 3 different types of methods in the class. All the class activities are performed using all these methods.

• Instance Methods
• Class Methods

In inheritance, the new class is to be derived from the existing class. By inheritance, the variables and methods of the existing class are accessible in the new class. All classes in python are derived from the object class. When we create a Python class, internally the object class becomes the superclass. The main advantage of inheritance is code accessibility.

							
class Student(object)
  pass
  
class Student:
  pass

If we write a constructor in both the classes then the child class can’t access the constructor of a parent class. In such a case only child class constructor is available i.e. child class constructor replaces parent class constructor. Constructor Overriding is used when the existing constructor has to be modified.

							
class University: 
  def __init__(self): 
    self.name = 'Yele University'
    print("You are in University Class Constructor")
 
class College (University):
  def __init__(self):
    self.name = 'Yale School of Medicine'
    print('You are in college Class Constructor')
 
  def show(self):
    print('College class instance method:',self.name)
 
college = College()
college.show()

Funny Fact :

Here is a fun fact, Python is an old programming language even older than Java.

If we write a constructor in both the classes then the parent class constructor is not available in the child class. In such a case, the child class constructor replaces the parent class constructor. If we want to access the parent class constructor then we have to use the super method.

The polymorphism, poly meaning many, and morphos meaning forms. If there is a different behavior according to a variable or method situation, then it is called Polymorphism. Given below are 3 different types of Polymorphism.

• Duck Typing
• Operator Overloading
• Method Overriding

When an object is passed in strong typing, then it is checked whether the method is present or not in that object. Using Python’s hasattr() function, you can check whether the method is present in the passed object.

If we write the same name method in child class and parent class then a method of parent class is not accessible in child class. In such a case, the method of the child class replaces the method of the parent class. Method overriding is used when we have to change the existing behavior of the program.

Python does not have an explicit interface concept like other languages such as Java. The interface in python is that there is only an abstract method in an abstract class and there is no concrete method.

Let's dig a little deeper :

Python programming language is high in demand with drastic growth in the past 10 years.

An abstract class has abstract methods as well as concrete methods but all methods in an interface are abstract methods. We use abstract class when all the objects share common features whereas we use interface when all the features are implemented differently for different objects. It is the programmer’s responsibility to write a child class in an abstract class, while any third-party vendor can write a child class in the interface. The interface is slow as compared to an abstract class.

Python has encapsulation which we use in class. There is no access control to access private and public attributes in a python class. Single and double underscores are used for naming conventions in python classes. The single underscore variable is called private and accessing it directly should be avoided. Double underscore attributes are also private, which python mangles to hide the attribute name.

The base class for enums is Enum. To create an enumeration we need to subclass it. Each member of an enumeration has a type of enumeration class itself. Enums are callables, and we can look up a member by value by calling the enumeration.

The del method is called before the object is about to be garbage collected. This is sometimes called the finalizer. It is sometimes referred to as the destructor, but that’s not really accurate since that method does not destroy the object – that’s the Garbage Collector’s responsibility – del just gets called prior to the GC destroying the object.

The process of creating a list while performing some operation on the data so that it can be accessed using an iterator is referred to as List Comprehension.

[ord (j) for j in string.ascii_uppercase]
[65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90]

								
a=('1')
b=2
c=int(a)+b
print c
	

print chr(97) and print ord(‘a’) for character to integer.

Using random keyword

							

import random
foo = ['a', 'b', 'c', 'd', 'e']
print (random.choice(foo))

							
a='abc'
print a[0].upper()

In short note :

Python feature allows to return multiple values using function.

def fun():
x = 6
y=3
a=x+y
b=x-y
Return a, b;
a, b = fun()
print(a)
print(b)

							
character=("india")
if (character == character.upper()):
print "uppercase"
else:
print "lowercase"
	

If you know the element you want to remove (but not the index), you can use remove: del removes a specific index: remove removes the first matching value, not a specific index:

							
from math import factorial
print factorial(8)
or
a=input("enter the input")
factorial=1
for i in range(1,a + 1):
factorial=factorial*i
print factorial

							
a=raw_input("enter the string : ")
letters=0
num=0
for x in a:
if x.isdigit():
num= num + 1
else:
letters=letters + 1
print "Letters:" ,letters
print "Digits :" ,num

							
a=raw_input("enter the number : ")
x1=a
x2=a+a
x3=a+a+a
x4=a+a+a+a
b=int(x1)+int(x2)+int(x3)+int(x4)
print b

							
from math import factorial
c=[]
a=input("enter the number : ")
for i in a:
if i%2!=0:
b=i**2
c.append(b)
print c