Python

Numpy is a library in Python which is used for scientific computing.The main object provided by numpy is array.Array in numpy is know as ndarray or simply array.It is important to note that numpy array is different from Python array.

To create a numpy array use the following syntax:

Import the nump library:

import numpy as np

Create a numpy array

arrObj = np.array([1,2])

Now if you print the array you will get the following:

print(arrObj )

Output:

[1,2]

Few important things to remember about numpy arrays:

• Shape is the dimension of the array.In the above example it is 2.
• Size is the total elements in the array.So if the dimension of the array is x,y then its size will be x*y

Basic operations

If you define two numpy arrays as

a = np.array( [1,2,3,4] )
b = np.arange([2,2,2,2] )

the doing  a+b will output the following array:

array([3, 4, 5, 6])

as you can see numpy array automatically adds elements of the two arrays.

Creating from a List

You can create a numpy array from list by passing list as the argument:

lst= [1,2,6,7]
arrObj= np.array(lst)

ashish

It is very simple to create a client and server application in Python.Infact you don’t need any web server to create a simple client server application in Python.Python provides several modules for accessing the network using different protocols.

The urllib package contains the modules for accessing the network resources.

For example to create a HTTP Server you can use the following example:

from http.server import HTTPServer, SimpleHTTPRequestHandler
httpserver = HTTPServer(("", 8000), SimpleHTTPRequestHandler)
httpserver .serve_forever()

The BaseHTTPRequestHandler is a module which is used for creating webserver.It is implemented by derived classes.Two such classes are SimpleHTTPServer and CGIHTTPServer modules.In this example we are using the SimpleHTTPRequestHandler for serving the contents of a file.

To create a client which calls the above webserver to access the file contents you can use the following sample:

from urllib.request import urlopen
file = urlopen("http://localhost:8000")
print(file.readlines())

ashish

Dictionary  in Python like list is a collection of objects.Unlike lists ,items in dictionary are accessed by key.Similar to lists ,items can be added or removed from dictionary.While the items in a list are sorted in a specific order ,the items in a dictionary are not sorted.The size of dictionary is not fixed ,items can be added or removed from the dictionary.

Creating a dictionary

To create a dictionary you specify key,value pairs.The keys and values are separated by colon.

Dictionary is declared using the parenthesis as:

dict = {'item1': 1, 'item2': 2}

In the above dictionary there are two elements.The key of first element is ‘item1’ and key of the second element is ‘item2’ .

once dictionary is declared you can modify the dictionary by using the key as:

dict['item2']="two"

You can get the length of the dictionary by using the len() function as:

dict.len(dict)

The items in the dictionary can be retreived by using the items method as:

dict.items()

Removing item from a dictionary

You can delete item from a dictionary using the del keyword as:

del sampleDict['2']

looping through the items in the dictionary

for x in sampleDict:
print('x=%s'%(sampleDict[x]))

ashish

Declaring a class

We define a class in Python using the class keyword.To define a class called Main we use the following:

class Main:
   def __init__(self):
     self.tempVar= 1

def SetValue(self,value):
     self.EmpId=value
     def GetValue(self):
     print("EmpId=%s"%(self.EmpId))

There are few important points to be noted in the above code:
1.Class is defined using the class keyword.Here the name of the class is Main.
2.Class initialization happens in a method called __init__.It is similar to class constructor in other languages.
3.Methods are defined in a similar way as normal functions using the def statement followed by method name.
4.self is the parameter defined in the method above.It refers to the class object using which the method is callled.So if you have two different objects a and b then self will refer to a when called using the object a and it will refer to b when called using the object b.

We can declare objects of the above class as:

obj1=Main()
obj1.SetValue(1)
obj1.GetValue()

obj2=Main()
obj2.SetValue(2)
obj2.GetValue()

Inheritance

A class can inherit the attributes from another class.In the following example we are defining a class called Inherited which inherits its behaviour from class Main.

class Inherited(Main):
    def Message(self):
      print("Hello from Inherited")
      print("EmpId=%d"%(self.tempVar))

Following are the main points in the class declaration above:
1.A inherited class is declared just like a normal class.But after the nanme of the class we pass parent class name in brackets.
2.The inherited class has access to the variables of the parent class.In the above sample we are accessing the variable called tempVar in the derived class.

Multilevel Inheritance

You can implement multilevel inheritance as:

class FirstClass:
   pass


class SecondClass(FirstClass):
   pass


class ThirdClass(SecondClass):
   pass

Calling parent class constructor

The constructor defined in the child class is called when the object of child class is created.So if  the child class defines the following constructor,then only this constructor will be called and the parent class constructor will not be called.

def__init__(self):
Main.__init__(self)
print("child constructor")

 class Main:
def__init__(self):
self.tempVar=1
print("base constructor")

super().parentMethodName(args)

ashish