Python Basics

What are the different data types in Python?

noreply@blogger.com (sudhakar mishra) — Sat, 22 Apr 2017 16:29:00 +0000

Python Datatypes:

Boolean
Numbers
Strings
Lists
Tuples
Sets
Dictionaries

Boolean:

Booleans are either true or false.
Python has 2 constants named True and False which can be used to assign a boolean value directly.
In certain places ( like if statements ), Python expects an expression to a boolean value, these places are called boolean contexts.

Numbers:

Python supports both int and floating point numbers.

Tuples:

A tuple is an immutable list, it means a tuple can't be changed in a way once it's created.
A tuple is defined in the same way as a list, except that the whole set of an element is enclosed in the parenthesis instead of square brackets.
Similarities with the list :

Tuples have a defined order i.e. Indices are 0 based, so the first element of a non-empty tuple is always a_tuple[ 0 ].
Negative indices count from the end of the tuple.
Slicing works too, when we slice a list we get a new list. When we slice a tuple, we get a new tuple.

The difference with lists:

Tuple can't be changed. In technical terms, tuples are immutable in practical terms, tuples have no methods that would allow to change them. List have methods like append() , extend(), insert() , remove() and pop().
Tuples are faster than lists. In CPython, tuples are stored in a single block of memory, so creating a new tuple involves at worst a single call to allocate memory. Lists are allocated in two blocks: the fixed one with all the Python object information and a variable sized block for the data. That's part of the reason why creating a tuple is faster, but it probably also explains the slight difference in indexing speed as there is one fewer pointer to follow.
Tuples make code safer since they are "write-protect".

Sets :

A set is an unordered "bag" of unique values.
A single set can contain values of any immutable datatype.
Once we have two sets, we can do standard operations like union, intersection and set difference.

What is composite key?

noreply@blogger.com (sudhakar mishra) — Sat, 22 Apr 2017 13:55:00 +0000

Composite Key :

A composite key is a combination of two or more columns in a table that can be used to uniquely identify each row in the table.
When the columns are combined uniqueness is guaranteed but when it taken individually it does not guarantee uniqueness.
Sometimes more than one attributes are needed to uniquely identify an entity.
A primary key that is made by the combination of more than one attribute is known as a composite key.
Ex :

Create table abc ( c1 int , c2 varchar(20), c3 varchar(100) , PRIMARY KEY ( c1, c2 ) );

Explain pickling and unpickling in python.

noreply@blogger.com (sudhakar mishra) — Sat, 22 Apr 2017 04:34:00 +0000

Pickling and Unpickling:

Pickle is a standard module which serializes and deserializes a python object structure.
Pickle module accepts any python object, converts it into a string representation and dumps into a file(by using dump() function ) which can be used later this process is called pickling.
Unpickling is a process of retrieving original python object from the stored string representation for use.
Pickling is a process whereby a python object hierarchy is converted into a byte stream and unpickling is the inverse operation, whereby a byte stream is converted back into an object hierarchy.
Ex:

import pickle

a = [ "apple" , "banana" ]

file_Name = "abc"

# open the file for writing

fileObj = open( file_Name , "wb" )

# This writes the object a to the file

pickle.dump( a , fileObj)

fileObj.close()

fileObj = open( file_Name , "r")

# load the object from the file into variable

b = pickle.load( fileObj )

print( a == b ) # True

What is list comprehension? Also explain generator comprehension, set comprehension and dictionary comprehension?

noreply@blogger.com (sudhakar mishra) — Fri, 21 Apr 2017 19:46:00 +0000

List Comprehension :

List comprehension was introduced in 2.0.
List comprehension is an elegant way to define and create a list in Python.
List comprehension is a complete substitute for the lambda function as well as the functions map(), filter() and reduce().

>>> Celsius = [39.2, 36.5, 37.3, 37.8]

>>> Fahrenheit = [ ((float(9)/5)*x + 32) for x in Celsius ]

>>> print Fahrenheit

[102.56, 97.700000000000003, 99.140000000000001, 100.03999999999999]

Generator Comprehension :

Generator comprehensions were introduced with Python 2.6.
They are simply a generator expression with a parenthesis - round brackets - around it. Otherwise, the syntax and the way of working is like list comprehension, but a generator comprehension returns a generator instead of a list.

>>> x = (x **2 for x in range(20))

>>> print(x)

at 0xb7307aa4>

>>> x = list(x)

>>> print(x)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]

Set Comprehension :

A set comprehension is similar to a list comprehension but returns a set and not a list.
Syntactically, we use curly brackets instead of square brackets to create a set.
We are able to create the set of non primes without doublets:

>>> from math import sqrt

>>> n = 100

>>> sqrt_n = int(sqrt(n))

>>> no_primes = {j for i in range(2,sqrt_n) for j in range(i*2, n, i)}

>>> no_primes

{4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36, 38, 39, 40, 42, 44, 45, 46, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 60, 62, 63, 64, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 81, 82, 84, 85, 86, 87, 88, 90, 91, 92, 93, 94, 95, 96, 98, 99}

>>> primes = {i for i in range(n) if i not in no_primes}

>>> print(primes)

{0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97}

>>>

Dictionary Comprehensions :

There are dictionary comprehensions in Python 2.7+.
Like a list comprehension, they create a new dictionary; you can't use them to add keys to an existing dictionary. Also, you have to specify the keys and values, although of course you can specify a dummy value if you like.

>>> d = {n: n**2 for n in range(5)}

>>> print d

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

my_list = ['hello', 'hi', 'hello', 'today', 'morning', 'again', 'hello']

my_dict = {k:my_list.count(k) for k in my_list}

print(my_dict)

{'again': 1, 'hi': 1, 'hello': 3, 'today': 1, 'morning': 1}

Explain slicing and indexing operations.

noreply@blogger.com (sudhakar mishra) — Fri, 21 Apr 2017 18:16:00 +0000

Slicing and Indexing operations :

Indexing operation allows to access a particular item in the sequence directly.
Slicing operation allows to retrieve a part of the sequence.
In slicing :

S[ StartNo : StopNo : Step ]

If the start no is omitted, Python will start at the beginning of the sequence.
If the stop no is omitted, Python will stop at the end of the sequence.

>>> a = [1,2,3,4]

>>> a[0:2] # take items 0-2, upper bound noninclusive

[1, 2]

>>> a[0:-1] #take all but the last

[1, 2, 3]

>>> a[1:4]

[2, 3, 4]

>>> a[::-1] # reverse the list

[4, 3, 2, 1]

>>> a[::2] # skip 2

[1, 3]

What is persistent cookie?

noreply@blogger.com (sudhakar mishra) — Fri, 21 Apr 2017 07:09:00 +0000

Persistent Cookie :

Also called a permanent cookie, or a stored cookie, a cookie that is stored on a user's hard drive until it expires (persistent cookies are set with expiration dates) or until the user deletes the cookie.
Persistent cookies are used to collect identifying information about the user, such as Web surfing behavior or user preferences for a specific Web site.
A persistent cookie enables a website to remember you on subsequent visits, speeding up or enhancing your experience of services or functions offered.
For example, a website may offer its contents in different languages. On my first visit, I may choose to have the content delivered in French and the site may record that preference in a persistent cookie set on your browser. When you revisit that site it will use the cookie to ensure that the content is delivered in French.

Session Cookie :

Also called a transient cookie, a cookie that is erased when the user closes the Web browser. The session cookie is stored in temporary memory and is not retained after the browser is closed. Session cookies do not collect information from the user's computer.
They typically will store information in the form of a session identification that does not personally identify the user.

Interview questions and answers

noreply@blogger.com (sudhakar mishra) — Sun, 16 Apr 2017 10:10:00 +0000

Ques: How are the functions help() and dir() different?

Ans: These are the two functions that are accessible from the Python Interpreter. These two functions are used for viewing a consolidated dump of built-in functions.

help :

It will display the documentation string. It is used to see the help related to modules, keywords, attributes, etc.
To view the help for a keyword, topics, you just need to type, help("<keyword>")

dir :

Without arguments, it will return list of names in the current local scope.
With an argument, it will return a list of valid attributes for that object.

Ques: Which statement of Python is used whenever a statement is required syntactically but the program needs no action?

Ans: pass is no-operation / action statement in Python.

If we want to get data from a model and even if the requested data does not exist, we want to continue with other tasks. In such a scenario, use try-except block with pass statement in the except block. Ex:

obj = None

try :

obj = ModelName.objects.get(pk=112)

except :

pass

Ques: What is a Python module?

Ans: A module is a Python script that generally contains import statements, functions, classes and variable definitions, and Python runnable code and it “lives” file with a ‘.py’ extension. zip files and DLL files can also be modules.Inside the module, you can refer to the module name as a string that is stored in the global variable name .

A module can be imported by other modules in one of the two ways. They are

import
from module-name import

Ques: Name the File-related modules in Python?

Ans: Python provides libraries / modules with functions that enable you to manipulate text files and binary files on file system. Using them you can create files, update their contents, copy, and delete files. The libraries are : os, os.path, and shutil.

os and os.path – modules include functions for accessing the filesystem
shutil – module enables you to copy and delete the files.

Ques: Explain the shortest way to open a text file and display its contents?

Ans: The shortest way to open a text file is by using “with” command as follows:

with open("file-name", "r") as fp:

fileData = fp.read()

#to print the contents of the file print(fileData)

Ques: How do you create a dictionary which can preserve the order of pairs?

Ans: We know that regular Python dictionaries iterate over <key, value> pairs in an arbitrary order, hence they do not preserve the insertion order of <key, value> pairs.

Python 2.7. introduced a new “OrderDict” class in the “collections” module and it provides the same interface like the general dictionaries but it traverse through keys and values in an ordered manner depending on when a key was first inserted.

Ex:

from collections import OrderedDict

d = OrderDict([('Company-id':1),('Company-Name':'ABC')])

d.items() # displays the output as: [('Company-id':1),('Company-Name':'ABC')]

Ques: When does a dictionary is used instead of a list?

Ans: Dictionaries are best suited when the data is labelled, i.e., the data is a record with field names.

Lists are better option to store collections of un-labelled items say all the files and sub directories in a folder.

Generally search operation on dictionary object is faster than searching a list object.

Ques: What is the use of enumerate() in Python?

Ans: Using enumerate() function we can iterate through the sequence and retrieve the index position and its corresponding value at the same time.

for i,v in enumerate([‘abc’,’123’,’xyz’]):

print(i,v)

# 0 abc

# 1 123

# 2 xyz

Ques: How many kinds of sequences are supported by Python? What are they?

Ans: Python supports 7 sequence types. They are str, list, tuple, unicode, bytearray, xrange, and buffer. where xrange is deprecated in python 3.5.X.

Ques: Is Python object oriented? what is object oriented programming?

Ans : Yes. Python is Object Oriented Programming language. OOP is the programming paradigm based on classes and instances of those classes called objects. The features of OOP are:

Encapsulation, Data Abstraction, Inheritance, Polymorphism.

Ques: How instance variables are different from class variables?

Ans: Instance variables are the variables in an object that have values that are local to that object. Two objects of the same class maintain distinct values for their variables. These variables are accessed with “object-name.instancevariable-name”.

Class variables are the variables of class. All the objects of the same class will share value of “Class variables. They are accessed with their class name alone as “class- name.classvariable-name”. If you change the value of a class variable in one object, its new value is visible among all other objects of the same class. In the Java world, a variable that is declared as static is a class variable.

Ques: What is the reason for the try-except-else to exist?
Ans: A try block allows you to handle a expected error. The except block should only catch exceptions you are prepared to handle. If you handle an unexpected error, your code may do the wrong thing and hide bugs.

The else-clause runs when there is no exception but before the finally-clause. That is its primary purpose.

The most common use of an else-clause in a try-block is for a bit of beautification (aligning the exceptional outcomes and non-exceptional outcomes at the same level of indentation). This use is always optional and isn't strictly necessary.

n = Input("enter a number")
try:
recip = 1 / n
except ZeroDivisionError:
logging.info('Infinite result')
else:
logging.info('Finite result')

How sessions work in Django?

noreply@blogger.com (sudhakar mishra) — Sun, 16 Apr 2017 05:00:00 +0000

The session framework stores and retrieves data.
It stores the data on the server side and sends and receives the cookies.
Cookies contain a session ID, not the data itself unless we are using the cookie-based sessions.
Django provides support for anonymous sessions.

Configuring the session engine:

By default, Django stores sessions in our database. We can configure Django to store session data using these sessions engines:

Database-backed sessions
Cached sessions
File-based sessions
Cookie-based sessions

Database-backed sessions:

To use databased-backed sessions we need to add "django.contrib.sessions" to our INSTALLED_APPS setting.
After this configuration, we need to run manage.py migrate to install the database table that stores session data.

Cached sessions:

For better performance, we can use a cached-based session backend.
We should only use it if we are using Memcached cache backend.

File-based sessions:

To use file-based sessions, set the SESSION_ENGINE setting to "django.contrib.sessions.backends.file".
We can set SESSION_FILE_PATH setting (which defaults to output from tempfile.gettempdir(), most likely /tmp) to control where Django stores session files.

Cookie-based sessions:

To use cookies-based session, set the SESSION_ENGINE setting to "django.contrib.sessions.backends.signed_cookies".
If we use cookie-based sessions, pay extra care that our secret key is always kept completely secret, for any system which might be remotely accessible.

What is middleware in django?

noreply@blogger.com (sudhakar mishra) — Thu, 13 Apr 2017 19:25:00 +0000

Middleware :

Middleware is a framework of hooks into Django’s request/response processing.
Middleware is a lightweight plugin for Django.
It allows modifying request or response or the view parameters.
Each middleware component is responsible for doing some specific function. For example, Django includes a middleware component, AuthenticationMiddleware, that associates users with requests using sessions.
When to use middleware :

We can use middleware if you want to modify the request i.e HttpRequest object which is sent to the view. Or you might want to modify the HttpResponse object returned from the view. Both these can be achieved by using middleware.
We might want to perform an operation before the view executes. In such case, we would use a middleware.

Hooks and Application order :

Request phase :

During the request phase, before calling the view. Django applies middleware in the order it's defined in MIDDLE_CLASSES top-down.
2 hooks are available :

process_request() is called on each request before Django decides which view to execute.
process_view() is called just before Django calls the view.

Response phase :

During the response phase, after calling the view, middlewares are applied in reverse order from the bottom up.
3 hooks are available :

process_exception() :

It is called only if the view raised an exception

process_template_response() :

It is called only for template responses

process_response() :

It is called on all responses before they are returned to the browser.

It must return a HttpResponse or StreamingHttpResponse.

What is difference between multi-threading and multiprocessing?

noreply@blogger.com (sudhakar mishra) — Tue, 11 Apr 2017 07:17:00 +0000

Multi-threading vs Multiprocessing :

The threading module uses threads, the multiprocessing uses processes. The difference is that threads run in the same memory space, while processes have separate memory.This makes it a bit harder to share objects between processes with multiprocessing. Since threads use the same memory, precautions have to be taken or two threads will write to the same memory at the same time. This is what the global interpreter lock is for.
Multiprocessing :

Pross :

Separate memory space
Takes advantage of multiple CPUs & cores
Avoids GIL limitations for cPython
Child processes are interruptible/killable

Cons :

Inter-process communication (IPC) a little more complicated with more overhead.
Larger memory footprint.

Multi-threading :

Pross :

Lightweight - low memory footprint.
Shared memory - makes access to state from another context easier.
Allows you to easily make responsive UIs.
cPython C extension modules that properly release the GIL will run in parallel.
Great option for I/O-bound applications.

Cons :

Not interruptible / killable.
Code is usually harder to understand and to get right - the potential for race conditions increases dramatically
It will not resume the task if server restarts for any reason.

How are variables and memory managed in Python?

noreply@blogger.com (sudhakar mishra) — Mon, 10 Apr 2017 08:45:00 +0000

Memory management in Python :

When we create an object then the Python Virtual Machine handles the memory needed and where it shall be placed in the memory layout.
CPython uses a private heap for storing objects.
Memory management in Python involves a private heap containing all Python objects and data structures. The management of this private heap is ensured internally by the Python memory manager.
The Python memory manager has different components which deal with various dynamic storage management aspects, like sharing, segmentation, preallocation or caching.
The algorithm used for garbage collecting is called Reference counting. That is the Python VM keeps an internal journal of how many references refer to an object, and automatically garbage collects it when there are no more references referring to it.
The management of the Python heap is performed by the interpreter itself and that the user has no control over it.
At the lowest level Raw Memory Allocator interacting with Memory Manager of OS to ensure that there is enough space / room in private heap.

Explain about assert statement?

noreply@blogger.com (sudhakar mishra) — Fri, 07 Apr 2017 08:59:00 +0000

Assertion :

An assertion is a sanity-check that you can turn on or turn off when you are done with your testing of the program.
We often place assertions at the start of a function to check for valid input, and after a function call to check for valid output.

The assert Statement :

When encounters an assert statement, Python evaluates the accompanying expression, which is hopefully true. If the expression is false, Python raises an AssertionError exception.
Syntax :

assert Expression[, Arguments]

If the assertion fails, Python uses ArgumentExpression as the argument for the AssertionError.
AssertionError exceptions can be caught and handled like any other exception using the try-except statement, but if not handled, they will terminate the program and produce a traceback.
Ex :

>>> def addOne(n):

... assert (n >= 0),"n should be greator than or equal to 0."

... return n + 1

...

>>> addOne(1)

>>> addOne(-1)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

File "<stdin>", line 2, in addOne

AssertionError: n should be greator than or equal to 0.

What is a negative index?

noreply@blogger.com (sudhakar mishra) — Fri, 07 Apr 2017 05:23:00 +0000

Negative index in python :

Python list items can be accessed with positive or negative index.
If list of size n then

0 positive index // first index

1 positive index // second index

(n-1) // last index

-n // first index

-(n-1) // second

-1 // last index

List indexes of -x mean the xth item from the end of the list, so n[-1] means the last item in the list n.
Negative numbers mean that you count from the right instead of the left. So, list[-1] refers to the last element, list[-2] is the second-last, and so on.
Ex:

If we have a list a = [1,2,3,4] then a[-1] will refer to 4 and a[-2] refer to 3.

What is repr function?

noreply@blogger.com (sudhakar mishra) — Fri, 07 Apr 2017 05:08:00 +0000

__repr__ function :

The __repr__ function returns a string representation of a Python object that may be evaluated by the Python interpreter to instantiate another instance of the object.
Called by the repr() built-in function and by string conversions (reverse quotes) to compute the "official" string representation of an object.
repr() tries to convert everything into a string that can be used with eval() to re-generate the original object.
repr() generates a computer friendly output.
str() is used by print() function to generate a user-friendly output.
str()'s output may or may not be used with eval().

>>> eval("'Hello'")
'Hello'

>>> eval('Hello')
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
eval('Hello')
File "<string>", line 1, in <module>
NameError: name 'Hello' is not defined

What is Python?

noreply@blogger.com (sudhakar mishra) — Tue, 04 Apr 2017 11:58:00 +0000

Python :

Python is an interpreted language. Python does not need to be compiled before it is run. Other interpreted languages include PHP and Ruby.
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 x=123 and then x="Hello" without an error.
Python is well suited to object orientated programming in that it allows the definition of classes along with composition and inheritance.
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 also first class objects.
Writing Python code is quick but running it is often slower than compiled languages. Python allows the inclusion of C based extensions so 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 does isn't actually done by Python.
Python finds use in many spheres - web applications, automation, scientific modeling, big data applications and many more. It's also often used as "glue" code to get other languages and components to play nice.
Python makes difficult things easy so programmers can focus on overriding algorithms and structures rather than low-level details.
Features / Advantages of Python :

Simple and minimalistic
Open source
High-level language:

Never need to bother about the low-level details such as managing the memory used by the program.

Interpreted:

We doesn't need to compile and convert it to binary. It just the program directly from the source code.
Python coverts source code written by the programmer into intermediate language i.e. byte code, which is again translated it into the native language / machine language that is executed so python is an interpreted language.

Python supports Object Oriented as well as procedure oriented programming.
Dynamically typed language

Disadvantages of Python :

Python is not the best for memory intensive task.
Python is an interpreted language and is slow compared to C/C++ or java.
Python is not a great choice for a high graphic 3D game that takes up a lot of CPU.

Describe functions in Python

noreply@blogger.com (sudhakar mishra) — Tue, 04 Apr 2017 11:31:00 +0000

Python Functions :

A function is a block of organized, reusable code that is used to perform a single, related action.
Python gives us many built-in functions like print(), etc. but you can also create your own functions. These functions are called user-defined functions.
Parameter Passing :

We can pass arguments to a function either by value or by reference.
Call by Value :

Sometimes it's also called pass by value.
In call-by-value, the argument expression is evaluated, and the result of this evaluation is bound to the corresponding variable in the function. So, if the expression is a variable, a local copy of its value will be used, i.e. the variable in the caller's scope will be unchanged when the function returns.

Call by Reference :

It is also known as pass-by-reference.
In this a function gets an implicit reference to the argument, rather than a copy of its value.
As a consequence, the function can modify the argument, i.e. the value of the variable in the caller's scope can be changed.
The function can modify the argument, i.e. the value of the variable in the caller's scope can be changed.
The disadvantage of it is that variables can be "accidentally" changed in a function call. So special care has to be taken to "protect" the values, which shouldn't be changed.

What is used in Python?

Python uses a mechanism, which is known as "Call-by-Object", sometimes also called "Call by Object Reference" or "Call by Sharing".
If you pass immutable arguments like integers, strings or tuples to a function, the passing acts like call-by-value. The object reference is passed to the function parameters. They can't be changed within the function, because they can't be changed at all, i.e. they are immutable.
It's different, if we pass mutable arguments. They are also passed by object reference, but they can be changed in place in the function. If we pass a list to a function, we have to consider two cases: Elements of a list can be changed in place, i.e. the list will be changed even in the caller's scope. If a new list is assigned to the name, the old list will not be affected, i.e. the list in the caller's scope will remain untouched.

What are Lambda expressions in python?

noreply@blogger.com (sudhakar mishra) — Tue, 04 Apr 2017 05:38:00 +0000

Lambda expressions:

Lambda functions are single-expression functions that are not necessarily bound to a name.
Lambda expression is an anonymous function.
Executing a lambda function evaluates its expression and then automatically returns its result. So there is always an implicit return statement.
It's a shorthand that allows us to write a method in the same place we are going to use it.
The difference between lambdas and regular function definitions is that lambda functions are restricted to a single expression. This means a lambda function can't use statements or annotations, not even a return statement.
Example:

double = lambda x: x * 2

double(2) # it will return 4

Explain decorators in python

noreply@blogger.com (sudhakar mishra) — Tue, 04 Apr 2017 05:10:00 +0000

Decorator :

Decorator is the name used for a software design pattern.
It is used to alter functions and methods.
Decorators work as wrappers, modifying the behavior of the code before and after a target function execution, without the need to modify the function itself, augmenting the original functionality.
Basically, a decorator takes in a function, adds some functionality and returns it.
Multiple decorators can be chained in Python.
For ex :

def addOne(myFun):

def addOneInside(*args,**kwrgs):

return myFun(*args,**kwrgs) + 1

return addOneInside

@addOne

def oldFun( x = 1 ):

return x

print oldFun(564) # prints 565

Save a file in model without using Django forms

noreply@blogger.com (sudhakar mishra) — Fri, 31 Mar 2017 06:54:00 +0000

If you want to store the document without using Django forms then you can use below code :

in models.py

...

class UserProfile(models.Model) :

user = models.OneToOneField(User)

doc = models.FileField(upload_to='uploads/', blank=True)

in python script

from core.models import UserProfile

from django.core.files import File

user1 = UserProfile(pk = 1)

user1.doc.save('resume.pdf', File(open('/tmp/resume.pdf', 'r')))

Explain Inheritance in python.

noreply@blogger.com (sudhakar mishra) — Tue, 21 Mar 2017 10:27:00 +0000

Inheritance :

Inheritance enables us to define a class that takes all the functionality from a parent class and allows us to add more.
Classes can inherit from other classes. A class can inherit attributes and behavior methods from another class, called the superclass.
A class which inherits from a superclass is called a subclass, also called heir class or child class. Superclasses are sometimes called ancestors as well.
Syntax :

class DerivedClass(BaseClass) :

body_of_derived_class

A derived class inherits features from the base class, adding new features to it. This results in re-usability of code.
If an attribute is not found in the class, the search continues to the base class. This repeats recursively if the base class is derived from other classes.
Ex :

class Polygon:

def __init__(self, no_of_sides):

self.n = no_of_sides

self.sides = [0 for i in range(no_of_sides)]

def inputSides(self):

self.sides = [float(input("Enter side "+str(i+1)+" : ")) for i in range(self.n)]

def dispSides(self):

for i in range(self.n):

print("Side",i+1,"is",self.sides[i])

class Triangle(Polygon):

def __init__(self):

Polygon.__init__(self,3)

def findArea(self):

a, b, c = self.sides

# calculate the semi-perimeter

s = (a + b + c) / 2

area = (s*(s-a)*(s-b)*(s-c)) ** 0.5

print('The area of the triangle is %0.2f' %area)

>>> t = Triangle()

>>> t.inputSides()

Enter side 1 : 3

Enter side 2 : 5

Enter side 3 : 4

>>> t.dispSides()

Side 1 is 3.0

Side 2 is 5.0

Side 3 is 4.0

>>> t.findArea()

The area of the triangle is 6.00

Method Overriding :

It is a feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its parent classes.
In the above example, __init__() method was defined in both classes, Triangle as well Polygon. When this happens, the method in the derived class overrides that in the base class. This is to say, __init__() in Triangle gets preference over the same in Polygon.
Generally when overriding a base method, we tend to extend the definition rather than simply replace it. The same is being done by calling the method in base class from the one in derived class (calling Polygon.__init__() from __init__() in Triangle).
A better option would be to use the built-in function super(). So, super().__init(3) is equivalent to Polygon.__init__(self,3) and is preferred.

isinstance() and issubclass() :

Two built-in functions isinstance() and issubclass() are used to check inheritances.
isinstance() returns True if the object is an instance of the class or other classes derived from it.
Each and every class in Python inherits from the base class object.
Ex :

>>> isinstance(t,Triangle)

True

>>> isinstance(t,Polygon)

True

>>> isinstance(t,int)

False

>>> isinstance(t,object)

True

>>> issubclass(Polygon,Triangle)

False

>>> issubclass(Triangle,Polygon)

True

>>> issubclass(bool,int)

True

Types :

Single Inheritance
Multiple Inheritance
Hierarchical Inheritance
Multilevel Inheritance
Hybrid Inheritance (also known as Virtual Inheritance)

Multiple Inheritance :

In multiple inheritance, the features of all the base classes are inherited into the derived class.
Syntax :

class Base1:

pass

class Base2:

pass

class MultiDerived(Base1, Base2):

pass

MRO (Method Resolution Order) :

The order in which base classes are searched when looking for a method is often called the Method Resolution Order.
In the multiple inheritance scenario, any specified attribute is searched first in the current class. If not found, the search continues into parent classes in depth-first, left-right fashion without searching same class twice.
So, in the above example of MultiDerived class the search order is [MultiDerived, Base1, Base2, object]. This order is also called linearization of MultiDerived class and the set of rules used to find this order is called Method Resolution Order (MRO).

What are Iterators and Generators in python?

noreply@blogger.com (sudhakar mishra) — Tue, 21 Mar 2017 10:25:00 +0000

Iterators :

An iterator is an object which allows us to traverse through all the elements of a collection, regardless of its specific implementation.
An iterator is an object which implements the iterator protocol.
The iterator protocol consists of two methods :

The __iter__() method, which must return the iterator object
The next() method, which returns the next element from a sequence

Python has several built-in objects, which implement the iterator protocol. For example lists, tuples, strings, dictionaries or files.
Advantages :

Cleaner code
Iterators can work with infinite sequences
Iterators save resources

By saving system resources means that when working with iterators, we can get the next element in a sequence without keeping the entire dataset in memory.

Generators :

Generators functions allow us to declare a function that behaves like an iterator.
A generator yields one value at a time, this requires less memory.
Generator uses the yield keyword.
For ex :

def fib_gen(n): a, b = 0, 1 for i in range(n): yield a a, b = b, a + b print list(fib_gen(10))

Advantage :

Memory efficient : Generators are good for calculating large sets of results where you don't know if you are going to need all results, or where you don't want to allocate the memory for all results at the same time.

What is a design pattern?

noreply@blogger.com (sudhakar mishra) — Tue, 21 Mar 2017 08:52:00 +0000

Design patterns :

Design patterns represent the best practices

Design patterns are solutions to general problems that software developers faced during software development.

Gang of Four (GOF)? :

In 1994, four authors Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides published a book titled Design Patterns - Elements of Reusable Object-Oriented Software which initiated the concept of Design Pattern in Software development.

These authors are collectively known as Gang of Four (GOF)

According to these authors design patterns are primarily based on the following principles of object orientated design:

Program to an interface not an implementation

Favor object composition over inheritance

Usage of Design Pattern :

Common platform for developers

Best Practices

Types of Design Patterns :

Creational Patterns :

These design patterns provide a way to create objects while hiding the creation logic, rather than instantiating objects directly using new operator.

It’ not commonly used in Python. Why? Because of the dynamic nature of the language.

This gives program more flexibility in deciding which objects need to be created for a given use case.

Ex. Singleton

Singleton :

The Singleton pattern is used when we want to guarantee that only one instance of a given class exists during runtime.

class Logger(object):
   def new(cls, *args, **kwargs):
       if not hasattr(cls, '_logger'):
           cls._logger = super(Logger, cls
                   ).new(cls, *args, **kwargs)
       return cls._logger

In this example, Logger is a Singleton.

Structural Patterns :

These design patterns concern class and object composition.

Ex. Facade, Adapter,Decorator

Behavioral Patterns :

These design patterns are specifically concerned with communication between objects.

According to GOF principles, there are a total of 11 behavioral patterns in Python: Chain of responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template, Visitor.

Explain map, filter, reduce and zip functions?

noreply@blogger.com (sudhakar mishra) — Tue, 21 Mar 2017 08:51:00 +0000

map:

It is a built-in higher-order function that operates on iterable.
Functions that can accept other functions as arguments and return function to the caller is known as Higher-order functions.
It takes a function and an iterable as arguments and returns a new iterable with the function applied to each item of iterable.

filter:

It filters an iterable by removing items that don’t match a predicate.
A predicate is a function that returns a Boolean.

reduce:

It continuously applies the function to sequence and returns a single value.

zip:

It takes two equal-length collections and merges them together in pairs.

Example:

nums = [ 11,22,33,44,55 ]

list1 = [ 1,2,3 ]

list2 = [ ‘a’,’b’,’c’ ]

>> zip( list1 , list2 ) # [(1, 'a'), (2, 'b'), (3, 'c')]

>> res = list( filter ( lambda x : x % 2 == 0 , nums ) )

>> print(res) # [ 22, 44 ]

>> print(map(lambda x : x + 5 , nums))

>> # prints [16, 27, 38, 49, 60]

>> print(reduce(lambda x,y : x + y , list1)) # prints 6

How to sort Dictionaries over values?

noreply@blogger.com (sudhakar mishra) — Tue, 21 Mar 2017 08:50:00 +0000

It is not possible to sort a dict, only to get a representation of a dict that is sorted. Dicts are inherently orderless, but other types, such as lists and tuples, are not. So we need a sorted representation, which will be a list—probably a list of tuples.

Soln 1 :

To sort on values :

import operator

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}

sorted_x = sorted(x.items(), key=operator.itemgetter(1))

sorted_x will be a list of tuples sorted by the second element in each tuple.dict(sorted_x) == x

To sort on keys :

import operator

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}

sorted_x = sorted(x.items(), key=operator.itemgetter(0))

Soln 2 :

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}

sorted_x = sorted( x.items(), key=lambda a : a[1] )

What can be key of a dictionary?

noreply@blogger.com (sudhakar mishra) — Tue, 21 Mar 2017 08:49:00 +0000

Key of a dictionary can be :

String

Numbers

tuples

List can’t be a key of a dictionary and also tuple of list can’t be same. If we assign a tuple of list as key then it will generate a TypeError: unhashable type: 'list'.

Python Basics

What are the different data types in Python?

What is composite key?

Explain pickling and unpickling in python.

What is list comprehension? Also explain generator comprehension, set comprehension and dictionary comprehension?

Explain slicing and indexing operations.

What is persistent cookie?

Interview questions and answers

How sessions work in Django?

What is middleware in django?

What is difference between multi-threading and multiprocessing?

How are variables and memory managed in Python?

Explain about assert statement?

What is a negative index?

What is __repr__ function?

What is Python?

Describe functions in Python

What are Lambda expressions in python?

Explain decorators in python

Save a file in model without using Django forms

Explain Inheritance in python.

What are Iterators and Generators in python?

What is a design pattern?

Explain map, filter, reduce and zip functions?

How to sort Dictionaries over values?

What can be key of a dictionary?

Key of a dictionary can be : String Numbers tuples List can’t be a key of a dictionary and also tuple of list can’t be same. If we assign a tuple of list as key then it will generate a TypeError: unhashable type: 'list'.

What is repr function?

Key of a dictionary can be :

String

Numbers

tuples

List can’t be a key of a dictionary and also tuple of list can’t be same. If we assign a tuple of list as key then it will generate a TypeError: unhashable type: 'list'.