OOPS in Python

python

Static method :- when to use or when not

One rule-of-thumb: ask yourself “does it make sense to call this method, even if no Obj has been constructed yet?” If so, it should definitely be static.

So in a class Car you might have a method double convertMpgToKpl(double mpg) which would be static, because one might want to know what 35mpg converts to, even if nobody has ever built a Car. But void setMileage(double mpg) (which sets the efficiency of one particular Car) can’t be static since it’s inconceivable to call the method before any Car has been constructed.

 

 

Python Interview latest question

Uncategorized

What is monkey patch :-

It’s simply the dynamic replacement of attributes at runtime.

For instance, consider a class that has a method get_data. This method does an external lookup (on a database or web API, for example), and various other methods in the class call it. However, in a unit test, you don’t want to depend on the external data source – so you dynamically replace the get_data method with a stub that returns some fixed data.

Because Python classes are mutable, and methods are just attributes of the class, you can do this as much as you like – and, in fact, you can even replace classes and functions in a module in exactly the same way.

2.The most common usecase is adding a workaround for a bug in a module or class when you can’t replace the original code. In this case you replace the “wrong” code through monkey patching with an implementation inside your own module/package.

Mcafee download manager to get 301 error through in local script instead of actual  scenario.

Decorator :- http://www.bogotobogo.com/python/python_decorators.php

it’s kind of wrapper for function , that will take function object as argument and return function object

http://www.artima.com/weblogs/viewpost.jsp?thread=240808   class decorator

 

 

Web services

Uncategorized

Web services way to communicate between 2 software as client and server

http://stackoverflow.com/questions/2131965/main-differences-between-soap-and-restful-web-services-in-java

different between web server and app server:-

http://stackoverflow.com/questions/936197/what-is-the-difference-between-application-server-and-web-server

 

http://www.bamboorocketapps.com/rest-json-vs-soap-xml/  REST  better than SOAP

 

Shell Script

Uncategorized

Soft and hard link:-

http://www.thegeekstuff.com/2010/10/linux-ln-command-examples/

softlink kind of reference with different inode file and if anything like permission change in reference file (not refer file) it will effect on refer file .

hardlink kind of same file (same inode) with 2 different copied , if you remove from 1 place still other file content you will be able to access

http://www.geekride.com/hard-link-vs-soft-link/

C interview practice

C

 

First, the C preprocessor cpp expands all those macros definitions and include statements (and anything else that starts with a #) and passes the result to the actual compiler. The preprocessor is not so interesting because it just replaces some short cuts you used in your code with more code. The output of cpp is just C code; if you didn’t have any preprocessor statements in your file, you wouldn’t need to run cpp. The preprocessor does not require any knowledge about the target architecture. If you had the correct include files, you could preprocess your C files on a LINUX machine and take the output to the instructional machines and pass that to cc. To see the output of a preprocessed file, use cc -E.

The compiler effectively translates preprocessed C code into assembly code, performing various optimizations along the way as well as register allocation. Since a compiler generates assembly code specific to a particular architecture, you cannot use the assembly output of cc from an Intel Pentium machine on one of the instructional machines (Digital Alpha machines). Compilers are very interesting which is one of the reasons why the department offers an entire course on compilers (CSE 401). To see the assembly code produced by the compiler, use cc -S.

The assembly code generated by the compilation step is then passed to the assembler which translates it into machine code; the resulting file is called an object file. On the instructional machines, both cc and gcc use the native assembler as that is provided by UNIX. You could write an assembly language program and pass it directly to as and even to cc (this is what we do in project 2 withsys.s). An object file is a binary representation of your program. The assembler gives a memory location to each variable and instruction; we will see later that these memory locations are actually represented symbolically or via offsets. It also make a lists of all the unresolved references that presumably will be defined in other object file or libraries, e.g. printf. A typical object file contains the program text (instructions) and data (constants and strings), information about instructions and data that depend on absolute addresses, a symbol table of unresolved references, and possibly some debugging information. The UNIX command nm allows you to look at the symbols (both defined and unresolved) in an object file.

Since an object file will be linked with other object files and libraries to produce a program, the assembler cannot assign absolute memory locations to all the instructions and data in a file. Rather, it writes some notes in the object file about how it assumed things were layed out. It is the job of the linker to use these notes to assign absolute memory locations to everything and resolve any unresolved references. Again, both cc and gcc on the instructional machines use the native linker, ld. Some compilers chose to have their own linkers, so that optimizations can be performed at link time; one such optimization is that of aligning procedures on page boundaries. The linker produces a binary executable that can be run from the command interface.

Notice that you could invoke each of the above steps by hand. Since it is an annoyance to call each part separately as well as pass the correct flags and files, cc does this for you. For example, you could run the entire process by hand by invoking /lib/cpp and then cc -S and then /bin/as and finally ld. If you think this is easy, try compiling a simple program in this way.

Running a Program

When you type a.out at the command line, a whole bunch of things must happen before your program is actually run. The loader magically does these things for you. On UNIX systems, the loader creates a process. This involves reading the file and creating an address space for the process. Page table entries for the instructions, data and program stack are created and the register set is initialized. Then the loader executes a jump instruction to the first instruction in the program. This generally causes a page fault and the first page of your instructions is brought into memory. On some systems the loader is a little more interesting. For example, on systems like Windows NT that provide support for dynamically loaded libraries (DLLs), the loader must resolve references to such libraries similar to the way a linker does.

 

  • The following Figure shows the steps involved in the process of building the C program starting from the compilation until the loading of the executable image into the memory for program running.
  • http://www.tenouk.com/ModuleW.html

Static and extern variable :- http://www.cquestions.com/2011/02/static-variable-in-c.html

 

 

PSTN

Telecom

Link :- http://electronics.howstuffworks.com/telephone-country-codes1.htm

Signaling :- The ITU-T defines signaling as, [47] “The exchange of information (other than by speech) specifically concerned with the establishment, release and other control of calls, and network management, in automatic telecommunications operation

digital singal good over analog signal :-

http://digital-signal-process.blogspot.in/2011/01/advantage-of-digital-over-analog-signal.html

 

SS7 short :-

An SS7 network is composed of service switching points (SSPs), signaling
transfer points (STPs), and service control points (SCPs). The SSP gathers
the analog signaling information from the local line in the network and converts
the information into a digital SS7 signaling message. These messages
are transferred into the SS7 network to STPs that transfer the packet closer
to its destination. When special processing of the message is required
such as routing a call to a call forwarding number, the STP routes a query
to a SEP. The SCP is a database that can use the incoming message to determine
other numbers and features that are associated with this particular
call.

 

Routing

Networking Basic

How table created :-

Routes to hosts or networks that are not directly connected must be entered into the routing table somehow. One common way is to execute the route command explicitly from the initialization files when the system is bootstrapped. On the host svr4 the following two commands were executed to add the entries that we showed earlier:

route add default sun 1
route add slip bsdi 1

Unfortunately, few systems agree on which start-up file contains the route commands. Under 4.4BSD and BSD/386 it is /etc/netstart, under SVR4 it is /etc/inet/rc.inet, under Solaris 2.x it is /etc/rc2.d/S69inet, SunOS 4.1.x uses /etc/rc.local, and AIX 3.2.2 uses /etc/rc.net.

Netstat command flag M / D:- redirect

  1. We assume that the host sends an IP datagram to Rl. This routing decision is often made because Rl is the default router for the host.
  2. Rl receives the datagram and performs a lookup in its routing table and determines that R2 is the correct next-hop router to send the datagram to. When it sends the datagram to R2, Rl detects that it is sending it out the same interface on which the datagram arrived (the LAN to which the host and the two routers are attached). This is the clue to a router that a redirect can be sent to the original sender.

Chapter 9. IP Routing

3. Rl sends an ICMP redirect to the host, telling it to send future datagrams to that destination to R2, instead of Rl.

Python __Main__

python

When the Python interpreter reads a source file, it executes all of the code found in it. Before executing the code, it will define a few special variables. For example, if the python interpreter is running that module (the source file) as the main program, it sets the special __name__ variable to have a value "__main__". If this file is being imported from another module, __name__ will be set to the module’s name.

In the case of your script, let’s assume that it’s executing as the main function, e.g. you said something like

python threading_example.py

on the command line. After setting up the special variables, it will execute the import statement and load those modules. It will then evaluate the def block, creating a function object and creating a variable called myfunction that points to the function object. It will then read the if statement and see that __name__does equal "__main__", so it will execute the block shown there.

One of the reasons for doing this is that sometimes you write a module (a .py file) where it can be executed directly. Alternatively, it can also be imported and used in another module. By doing the main check, you can have that code only execute when you want to run the module as a program and not have it execute when someone just wants to import your module and call your functions themselves.

 

 

The simplest explanation for the __name__ variable (imho) is the following:

Create the following files.

# a.py
import b

and

# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__

Running them will get you this output:

$ python a.py
Hello World from b!

As you can see, when a module is imported, Python sets globals()['__name__'] in this module to the module’s name.

$ python b.py
Hello World from __main__!
Hello World again from __main__!

As you can see, when a file is executed, Python sets globals()['__name__'] in this file to "__main__".

Python PYC :-

As an important speed-up of the start-up time for short programs that use a lot of standard modules, if a file called spam.pyc exists in the directory where spam.py is found, this is assumed to contain an already-“byte-compiled” version of the module spam. The modification time of the version of spam.py used to create spam.pyc is recorded in spam.pyc, and the .pyc file is ignored if these don’t match.

See the ref for more info. But some specific answers:

The contents of the spam.pyc file are platform independent, so a Python module directory can be shared by machines of different architectures.

It’s not an executable; it’s used internally by the compiler as an intermediate step.

In general, you don’t make .pyc files by hand: the interpreter makes them automatically.