C++ Interview Questions and Answers

• What is C++?
  
  Released in 1985, C++ is an object-oriented programming language created by Bjarne Stroustrup. C++ maintains almost all aspects of the C language, while simplifying memory management and adding several features - including a new datatype known as a class (you will learn more about these later) - to allow object-oriented programming. C++ maintains the features of C which allowed for low-level memory access but also gives the programmer new tools to simplify memory management.
  
  C++ used for:
  
  C++ is a powerful general-purpose programming language. It can be used to create small programs or large applications. It can be used to make CGI scripts or console-only DOS programs. C++ allows you to create programs to do almost anything you need to do. The creator of C++, Bjarne Stroustrup, has put together a partial list of applications written in C++.
• How do you find out if a linked-list has an end? (i.e. the list is not a cycle)
  
  You can find out by using 2 pointers. One of them goes 2 nodes each time. The second one goes at 1 nodes each time. If there is a cycle, the one that goes 2 nodes each time will eventually meet the one that goes slower. If that is the case, then you will know the linked-list is a cycle.
• 
  
• What is the difference between realloc() and free()?
  
  The free subroutine frees a block of memory previously allocated by the malloc subroutine. Undefined results occur if the Pointer parameter is not a valid pointer. If the Pointer parameter is a null value, no action will occur. The realloc subroutine changes the size of the block of memory pointed to by the Pointer parameter to the number of bytes specified by the Size parameter and returns a new pointer to the block. The pointer specified by the Pointer parameter must have been created with the malloc, calloc, or realloc subroutines and not been deallocated with the free or realloc subroutines. Undefined results occur if the Pointer parameter is not a valid pointer.
• What is function overloading and operator overloading?
  
• Function overloading: C++ enables several functions of the same name to be defined, as long as these functions have different sets of parameters (at least as far as their types are concerned). This capability is called function overloading. When an overloaded function is called, the C++ compiler selects the proper function by examining the number, types and order of the arguments in the call. Function overloading is commonly used to create several functions of the same name that perform similar tasks but on different data types.
  Operator overloading allows existing C++ operators to be redefined so that they work on objects of user-defined classes. Overloaded operators are syntactic sugar for equivalent function calls. They form a pleasant facade that doesn't add anything fundamental to the language (but they can improve understandability and reduce maintenance costs).
• What is the difference between declaration and definition?
  
  The declaration tells the compiler that at some later point we plan to present the definition of this declaration.
  E.g.: void stars () //function declaration
  The definition contains the actual implementation.
  E.g.: void stars () // declarator
  {
  for(int j=10; j > =0; j--) //function body
  cout << *;
  cout << endl; }
• What are the advantages of inheritance?
  
  It permits code reusability. Reusability saves time in program development. It encourages the reuse of proven and debugged high-quality software, thus reducing problem after a system becomes functional.
• How do you write a function that can reverse a linked-list?
  
  void reverselist(void)
  {
  if(head==0)
  return;
  if(head->next==0)
  return;
  if(head->next==tail)
  {
  head->next = 0;
  tail->next = head;
  }
  else
  {
  node* pre = head;
  node* cur = head->next;
  node* curnext = cur->next;
  head->next = 0;
  cur-> next = head;
  
  for(; curnext!=0; )
  {
  cur->next = pre;
  pre = cur;
  cur = curnext;
  curnext = curnext->next;
  }
  
  curnext->next = cur;
  }
  }
• 
  
• What do you mean by inline function?
  The idea behind inline functions is to insert the code of a called function at the point where the function is called. If done carefully, this can improve the application's performance in exchange for increased compile time and possibly (but not always) an increase in the size of the generated binary executables.
• Write a program that ask for user input from 5 to 9 then calculate the average
  #include "iostream.h"
  int main() {
  int MAX = 4;
  int total = 0;
  int average;
  int numb;
  for (int i=0; i<MAX; i++) {
  cout << "Please enter your input between 5 and 9: ";
  cin >> numb;
  while ( numb<5 || numb>9) {
  cout << "Invalid input, please re-enter: ";
  cin >> numb;
  }
  total = total + numb;
  }
  average = total/MAX;
  cout << "The average number is: " << average << "\n";
  return 0;
  }
• Write a short code using C++ to print out all odd number from 1 to 100 using a for loop
  for( unsigned int i = 1; i < = 100; i++ )
  if( i & 0x00000001 )
  cout << i << \",\";
• What is public, protected, private?
  Public, protected and private are three access specifier in C++.
  Public data members and member functions are accessible outside the class.
  Protected data members and member functions are only available to derived classes.
  Private data members and member functions can’t be accessed outside the class. However there is an exception can be using friend classes.
  Write a function that swaps the values of two integers, using int* as the argument type.
  void swap(int* a, int*b) {
  int t;
  t = *a;
  *a = *b;
  *b = t;
  }
• Tell how to check whether a linked list is circular.
  Create two pointers, each set to the start of the list. Update each as follows:
• while (pointer1) {
  pointer1 = pointer1->next;
  pointer2 = pointer2->next; if (pointer2) pointer2=pointer2->next;
  if (pointer1 == pointer2) {
  print (\"circular\n\");
  }
  }
• OK, why does this work?
  If a list is circular, at some point pointer2 will wrap around and be either at the item just before pointer1, or the item before that. Either way, it’s either 1 or 2 jumps until they meet.
• What is virtual constructors/destructors?
  Answer1
  Virtual destructors:
  If an object (with a non-virtual destructor) is destroyed explicitly by applying the delete operator to a base-class pointer to the object, the base-class destructor function (matching the pointer type) is called on the object.
  There is a simple solution to this problem declare a virtual base-class destructor.
  This makes all derived-class destructors virtual even though they don’t have the same name as the base-class destructor. Now, if the object in the hierarchy is destroyed explicitly by applying the delete operator to a base-class pointer to a derived-class object, the destructor for the appropriate class is called. Virtual constructor: Constructors cannot be virtual. Declaring a constructor as a virtual function is a syntax error.
  
  Answer2
  Virtual destructors: If an object (with a non-virtual destructor) is destroyed explicitly by applying the delete operator to a base-class pointer to the object, the base-class destructor function (matching the pointer type) is called on the object.
  There is a simple solution to this problem – declare a virtual base-class destructor. This makes all derived-class destructors virtual even though they don’t have the same name as the base-class destructor. Now, if the object in the hierarchy is destroyed explicitly by applying the delete operator to a base-class pointer to a derived-class object, the destructor for the appropriate class is called.
• Virtual constructor: Constructors cannot be virtual. Declaring a constructor as a virtual function is a syntax error. Does c++ support multilevel and multiple inheritance?
  Yes.
• What are the advantages of inheritance?
  • It permits code reusability.
  • Reusability saves time in program development.
  • It encourages the reuse of proven and debugged high-quality software, thus reducing problem after a system becomes functional.
• What is the difference between declaration and definition?
  The declaration tells the compiler that at some later point we plan to present the definition of this declaration.
  E.g.: void stars () //function declaration
  The definition contains the actual implementation.
  E.g.: void stars () // declarator
  {
  for(int j=10; j>=0; j--) //function body
  cout<<”*”;
  cout<<endl; }
• 
  
• What is the difference between an ARRAY and a LIST?
  Answer1
  Array is collection of homogeneous elements.
  List is collection of heterogeneous elements.
  
  For Array memory allocated is static and continuous.
  For List memory allocated is dynamic and Random.
  
  Array: User need not have to keep in track of next memory allocation.
  List: User has to keep in Track of next location where memory is allocated.
  
  Answer2
  Array uses direct access of stored members, list uses sequencial access for members.
  
  //With Array you have direct access to memory position 5
  Object x = a[5]; // x takes directly a reference to 5th element of array
  
  //With the list you have to cross all previous nodes in order to get the 5th node:
  list mylist;
  list::iterator it;
  
  for( it = list.begin() ; it != list.end() ; it++ )
  {
  if( i==5)
  {
  x = *it;
  break;
  }
  i++;
  }
• Does c++ support multilevel and multiple inheritance?
  Yes.
• What is a template?
  Templates allow to create generic functions that admit any data type as parameters and return value without having to overload the function with all the possible data types. Until certain point they fulfill the functionality of a macro. Its prototype is any of the two following ones:
  
  
  template <class indetifier> function_declaration; template <typename indetifier> function_declaration;
  The only difference between both prototypes is the use of keyword class or typename, its use is indistinct since both expressions have exactly the same meaning and behave exactly the same way.
• Define a constructor - What it is and how it might be called (2 methods).
  Answer1
  constructor is a member function of the class, with the name of the function being the same as the class name. It also specifies how the object should be initialized.
  
  Ways of calling constructor:
  1) Implicitly: automatically by complier when an object is created.
  2) Calling the constructors explicitly is possible, but it makes the code unverifiable.
  
  Answer2
  class Point2D{
  int x; int y;
  public Point2D() : x(0) , y(0) {} //default (no argument) constructor
  };
  
  main(){
  
  Point2D MyPoint; // Implicit Constructor call. In order to allocate memory on stack, the default constructor is implicitly called.
  
  Point2D * pPoint = new Point2D(); // Explicit Constructor call. In order to allocate memory on HEAP we call the default constructor.
• You have two pairs: new() and delete() and another pair : alloc() and free().
  Explain differences between eg. new() and malloc()
  Answer1
  1.) “new and delete” are preprocessors while “malloc() and free()” are functions. [we dont use brackets will calling new or delete].
  2.) no need of allocate the memory while using “new” but in “malloc()” we have to use “sizeof()”.
  3.) “new” will initlize the new memory to 0 but “malloc()” gives random value in the new alloted memory location [better to use calloc()]
  
  Answer2
  new() allocates continous space for the object instace
  malloc() allocates distributed space.
  new() is castless, meaning that allocates memory for this specific type,
  malloc(), calloc() allocate space for void * that is cated to the specific class type pointer.
• What is the difference between class and structure?
  Structure: Initially (in C) a structure was used to bundle different type of data types together to perform a particular functionality. But C++ extended the structure to contain functions also. The major difference is that all declarations inside a structure are by default public.
  Class: Class is a successor of Structure. By default all the members inside the class are private.
• 
  
• What is RTTI?
  Runtime type identification (RTTI) lets you find the dynamic type of an object when you have only a pointer or a reference to the base type. RTTI is the official way in standard C++ to discover the type of an object and to convert the type of a pointer or reference (that is, dynamic typing). The need came from practical experience with C++. RTTI replaces many Interview Questions - Homegrown versions with a solid, consistent approach.
• What is encapsulation?
  Packaging an object’s variables within its methods is called encapsulation.
• Explain term POLIMORPHISM and give an example using eg. SHAPE object: If I have a base class SHAPE, how would I define DRAW methods for two objects CIRCLE and SQUARE
  
  Answer1
  POLYMORPHISM : A phenomenon which enables an object to react differently to the same function call.
  in C++ it is attained by using a keyword virtual
  
  Example
  public class SHAPE
  {
  public virtual void SHAPE::DRAW()=0;
  }
  Note here the function DRAW() is pure virtual which means the sub classes must implement the DRAW() method and SHAPE cannot be instatiated
  
  public class CIRCLE::public SHAPE
  {
  public void CIRCLE::DRAW()
  {
  // TODO drawing circle
  }
  }
  public class SQUARE::public SHAPE
  {
  public void SQUARE::DRAW()
  {
  // TODO drawing square
  }
  }
  now from the user class the calls would be like
  globally
  SHAPE *newShape;
  
  When user action is to draw
  public void MENU::OnClickDrawCircle(){
  newShape = new CIRCLE();
  }
  
  public void MENU::OnClickDrawCircle(){
  newShape = new SQUARE();
  
  }
  
  the when user actually draws
  public void CANVAS::OnMouseOperations(){
  newShape->DRAW();
  }
  
  
  Answer2
  class SHAPE{
  public virtual Draw() = 0; //abstract class with a pure virtual method
  };
  
  class CIRCLE{
  public int r;
  public virtual Draw() { this->drawCircle(0,0,r); }
  };
  
  class SQURE
  public int a;
  public virtual Draw() { this->drawRectangular(0,0,a,a); }
  };
  
  Each object is driven down from SHAPE implementing Draw() function in its own way.
• What is an object?
  Object is a software bundle of variables and related methods. Objects have state and behavior.
• How can you tell what shell you are running on UNIX system?
  You can do the Echo $RANDOM. It will return a undefined variable if you are from the C-Shell, just a return prompt if you are from the Bourne shell, and a 5 digit random numbers if you are from the Korn shell. You could also do a ps -l and look for the shell with the highest PID.
• What do you mean by inheritance?
  Inheritance is the process of creating new classes, called derived classes, from existing classes or base classes. The derived class inherits all the capabilities of the base class, but can add embellishments and refinements of its own.
• 
  
• Describe PRIVATE, PROTECTED and PUBLIC – the differences and give examples.
  class Point2D{
  int x; int y;
  
  public int color;
  protected bool pinned;
  public Point2D() : x(0) , y(0) {} //default (no argument) constructor
  };
  
  Point2D MyPoint;
  
  You cannot directly access private data members when they are declared (implicitly) private:
  
  MyPoint.x = 5; // Compiler will issue a compile ERROR
  //Nor yoy can see them:
  int x_dim = MyPoint.x; // Compiler will issue a compile ERROR
  
  On the other hand, you can assign and read the public data members:
  
  MyPoint.color = 255; // no problem
  int col = MyPoint.color; // no problem
  
  With protected data members you can read them but not write them: MyPoint.pinned = true; // Compiler will issue a compile ERROR
  
  bool isPinned = MyPoint.pinned; // no problem
• What is namespace?
  Namespaces allow us to group a set of global classes, objects and/or functions under a name. To say it somehow, they serve to split the global scope in sub-scopes known as namespaces.
  The form to use namespaces is:
  namespace identifier { namespace-body }
  Where identifier is any valid identifier and namespace-body is the set of classes, objects and functions that are included within the namespace. For example:
  namespace general { int a, b; } In this case, a and b are normal variables integrated within the general namespace. In order to access to these variables from outside the namespace we have to use the scope operator ::. For example, to access the previous variables we would have to put:
  general::a general::b
  The functionality of namespaces is specially useful in case that there is a possibility that a global object or function can have the same name than another one, causing a redefinition error.
• What is a COPY CONSTRUCTOR and when is it called?
  A copy constructor is a method that accepts an object of the same class and copies it’s data members to the object on the left part of assignement:
  
  class Point2D{
  int x; int y;
  
  public int color;
  protected bool pinned;
  public Point2D() : x(0) , y(0) {} //default (no argument) constructor
  public Point2D( const Point2D & ) ;
  };
  
  Point2D::Point2D( const Point2D & p )
  {
  this->x = p.x;
  this->y = p.y;
  this->color = p.color;
  this->pinned = p.pinned;
  }
  
  main(){
  Point2D MyPoint;
  MyPoint.color = 345;
  Point2D AnotherPoint = Point2D( MyPoint ); // now AnotherPoint has color = 345
• 
  
• What is Boyce Codd Normal form?
  A relation schema R is in BCNF with respect to a set F of functional dependencies if for all functional dependencies in F+ of the form a-> , where a and b is a subset of R, at least one of the following holds:
  * a- > b is a trivial functional dependency (b is a subset of a)
  * a is a superkey for schema R
• What is virtual class and friend class?
  Friend classes are used when two or more classes are designed to work together and need access to each other's implementation in ways that the rest of the world shouldn't be allowed to have. In other words, they help keep private things private. For instance, it may be desirable for class DatabaseCursor to have more privilege to the internals of class Database than main() has.
• What is the word you will use when defining a function in base class to allow this function to be a polimorphic function?
  virtual
• What do you mean by binding of data and functions?
  Encapsulation.
• 
  
• What are 2 ways of exporting a function from a DLL?
  1.Taking a reference to the function from the DLL instance.
  2. Using the DLL ’s Type Library
• What is the difference between an object and a class?
  Classes and objects are separate but related concepts. Every object belongs to a class and every class contains one or more related objects.
  - A Class is static. All of the attributes of a class are fixed before, during, and after the execution of a program. The attributes of a class don't change.
  - The class to which an object belongs is also (usually) static. If a particular object belongs to a certain class at the time that it is created then it almost certainly will still belong to that class right up until the time that it is destroyed.
  - An Object on the other hand has a limited lifespan. Objects are created and eventually destroyed. Also during that lifetime, the attributes of the object may undergo significant change.
• Suppose that data is an array of 1000 integers. Write a single function call that will sort the 100 elements data [222] through data [321].
  quicksort ((data + 222), 100);
• 
  
• What is a class?
  Class is a user-defined data type in C++. It can be created to solve a particular kind of problem. After creation the user need not know the specifics of the working of a class.
• What is friend function?
  As the name suggests, the function acts as a friend to a class. As a friend of a class, it can access its private and protected members. A friend function is not a member of the class. But it must be listed in the class definition.
• Which recursive sorting technique always makes recursive calls to sort subarrays that are about half size of the original array?
  Mergesort always makes recursive calls to sort subarrays that are about half size of the original array, resulting in O(n log n) time.
• What is abstraction?
  Abstraction is of the process of hiding unwanted details from the user.
• What are virtual functions?
  A virtual function allows derived classes to replace the implementation provided by the base class. The compiler makes sure the replacement is always called whenever the object in question is actually of the derived class, even if the object is accessed by a base pointer rather than a derived pointer. This allows algorithms in the base class to be replaced in the derived class, even if users don't know about the derived class.
• What is the difference between an external iterator and an internal iterator? Describe an advantage of an external iterator.
  An internal iterator is implemented with member functions of the class that has items to step through. .An external iterator is implemented as a separate class that can be "attach" to the object that has items to step through. .An external iterator has the advantage that many difference iterators can be active simultaneously on the same object.
• What is a scope resolution operator?
  A scope resolution operator (::), can be used to define the member functions of a class outside the class.
• What do you mean by pure virtual functions?
  A pure virtual member function is a member function that the base class forces derived classes to provide. Normally these member functions have no implementation. Pure virtual functions are equated to zero.
  class Shape { public: virtual void draw() = 0; };
• What is polymorphism? Explain with an example?
  "Poly" means "many" and "morph" means "form". Polymorphism is the ability of an object (or reference) to assume (be replaced by) or become many different forms of object.
  Example: function overloading, function overriding, virtual functions. Another example can be a plus ‘+’ sign, used for adding two integers or for using it to concatenate two strings.
• 
  
• What’s the output of the following program? Why?
  #include <stdio.h>
  main()
  {
  typedef union
  {
  int a;
  char b[10];
  float c;
  }
  Union;
  
  Union x,y = {100};
  x.a = 50;
  strcpy(x.b,\"hello\");
  x.c = 21.50;
  
  printf(\"Union x : %d %s %f \n\",x.a,x.b,x.c );
  printf(\"Union y :%d %s%f \n\",y.a,y.b,y.c);
  }
  
  Given inputs X, Y, Z and operations | and & (meaning bitwise OR and AND, respectively)
  What is output equal to in
  output = (X & Y) | (X & Z) | (Y & Z)
• Why are arrays usually processed with for loop?
  The real power of arrays comes from their facility of using an index variable to traverse the array, accessing each element with the same expression a[i]. All the is needed to make this work is a iterated statement in which the variable i serves as a counter, incrementing from 0 to a.length -1. That is exactly what a loop does.
• What is an HTML tag?
  Answer: An HTML tag is a syntactical construct in the HTML language that abbreviates specific instructions to be executed when the HTML script is loaded into a Web browser. It is like a method in Java, a function in C++, a procedure in Pascal, or a subroutine in FORTRAN.
• Explain which of the following declarations will compile and what will be constant - a pointer or the value pointed at: * const char *
  * char const *
  * char * const
• 
  Note: Ask the candidate whether the first declaration is pointing to a string or a single character. Both explanations are correct, but if he says that it’s a single character pointer, ask why a whole string is initialized as char* in C++. If he says this is a string declaration, ask him to declare a pointer to a single character. Competent candidates should not have problems pointing out why const char* can be both a character and a string declaration, incompetent ones will come up with invalid reasons.
• You’re given a simple code for the class Bank Customer. Write the following functions:
  * Copy constructor
  * = operator overload
  * == operator overload
  * + operator overload (customers’ balances should be added up, as an example of joint account between husband and wife)
• 
  Note:Anyone confusing assignment and equality operators should be dismissed from the interview. The applicant might make a mistake of passing by value, not by reference. The candidate might also want to return a pointer, not a new object, from the addition operator. Slightly hint that you’d like the value to be changed outside the function, too, in the first case. Ask him whether the statement customer3 = customer1 + customer2 would work in the second case.
• What problems might the following macro bring to the application?
  #define sq(x) x*x
• Anything wrong with this code?
• T *p = new T[10];
  delete p;
• 
  Everything is correct, Only the first element of the array will be deleted”, The entire array will be deleted, but only the first element destructor will be called.
• Anything wrong with this code?
  T *p = 0;
  delete p;
• 
  Yes, the program will crash in an attempt to delete a null pointer.
• How do you decide which integer type to use?
  It depends on our requirement. When we are required an integer to be stored in 1 byte (means less than or equal to 255) we use short int, for 2 bytes we use int, for 8 bytes we use long int.
  
  A char is for 1-byte integers, a short is for 2-byte integers, an int is generally a 2-byte or 4-byte integer (though not necessarily), a long is a 4-byte integer, and a long long is a 8-byte integer. 
• 
  
• What does extern mean in a function declaration?
  Using extern in a function declaration we can make a function such that it can used outside the file in which it is defined.
  
  An extern variable, function definition, or declaration also makes the described variable or function usable by the succeeding part of the current source file. This declaration does not replace the definition. The declaration is used to describe the variable that is externally defined.
  
  If a declaration for an identifier already exists at file scope, any extern declaration of the same identifier found within a block refers to that same object. If no other declaration for the identifier exists at file scope, the identifier has external linkage.
• What can I safely assume about the initial values of variables which are not explicitly initialized?
  It depends on complier which may assign any garbage value to a variable if it is not initialized.
• What is the difference between char a[] = “string”; and char *p = “string”;?
  In the first case 6 bytes are allocated to the variable a which is fixed, where as in the second case if *p is assigned to some other value the allocate memory can change.
• What’s the auto keyword good for?
  Answer1
  Not much. It declares an object with automatic storage duration. Which means the object will be destroyed at the end of the objects scope. All variables in functions that are not declared as static and not dynamically allocated have automatic storage duration by default.
  
  For example
  int main()
  {
  int a; //this is the same as writing “auto int a;”
  }
  
  Answer2
  Local variables occur within a scope; they are “local” to a function. They are often called automatic variables because they automatically come into being when the scope is entered and automatically go away when the scope closes. The keyword auto makes this explicit, but local variables default to auto auto auto auto so it is never necessary to declare something as an auto auto auto auto.
• What is the difference between char a[] = “string”; and char *p = “string”; ?
  Answer1
  a[] = “string”;
  char *p = “string”;
  
  The difference is this:
  p is pointing to a constant string, you can never safely say
  p[3]=’x';
  however you can always say a[3]=’x';
  
  char a[]=”string”; - character array initialization.
  char *p=”string” ; - non-const pointer to a const-string.( this is permitted only in the case of char pointer in C++ to preserve backward compatibility with C.)
  
  Answer2
  a[] = “string”;
  char *p = “string”;
  
  a[] will have 7 bytes. However, p is only 4 bytes. P is pointing to an adress is either BSS or the data section (depending on which compiler — GNU for the former and CC for the latter).
  
  Answer3
  char a[] = “string”;
  char *p = “string”;
  
  for char a[]…….using the array notation 7 bytes of storage in the static memory block are taken up, one for each character and one for the terminating nul character.
  
  But, in the pointer notation char *p………….the same 7 bytes required, plus N bytes to store the pointer variable “p” (where N depends on the system but is usually a minimum of 2 bytes and can be 4 or more)……
• How do I declare an array of N pointers to functions returning pointers to functions returning pointers to characters?
  Answer1
  If you want the code to be even slightly readable, you will use typedefs.
  typedef char* (*functiontype_one)(void);
  typedef functiontype_one (*functiontype_two)(void);
  functiontype_two myarray[N]; //assuming N is a const integral
  
  Answer2
  char* (* (*a[N])())()
  Here a is that array. And according to question no function will not take any parameter value.
• What does extern mean in a function declaration?
  It tells the compiler that a variable or a function exists, even if the compiler hasn’t yet seen it in the file currently being compiled. This variable or function may be defined in another file or further down in the current file.
• 
  
• How do I initialize a pointer to a function?
  This is the way to initialize a pointer to a function
  void fun(int a)
  {
  
  }
  
  void main()
  {
  void (*fp)(int);
  fp=fun;
  fp(1);
  
  }
• How do you link a C++ program to C functions?
  By using the extern "C" linkage specification around the C function declarations.
• Explain the scope resolution operator.
  It permits a program to reference an identifier in the global scope that has been hidden by another identifier with the same name in the local scope.
• What are the differences between a C++ struct and C++ class?
  The default member and base-class access specifier are different.
• How many ways are there to initialize an int with a constant?
  Two.
  There are two formats for initializers in C++ as shown in the example that follows. The first format uses the traditional C notation. The second format uses constructor notation.
  int foo = 123;
  int bar (123);
• How does throwing and catching exceptions differ from using setjmp and longjmp?
  The throw operation calls the destructors for automatic objects instantiated since entry to the try block.
• What is a default constructor?
  Default constructor WITH arguments class B { public: B (int m = 0) : n (m) {} int n; }; int main(int argc, char *argv[]) { B b; return 0; }
• What is a conversion constructor?
  A constructor that accepts one argument of a different type.
• What is the difference between a copy constructor and an overloaded assignment operator?
  A copy constructor constructs a new object by using the content of the argument object. An overloaded assignment operator assigns the contents of an existing object to another existing object of the same class.
• When should you use multiple inheritance?
  There are three acceptable answers: "Never," "Rarely," and "When the problem domain cannot be accurately modeled any other way."
• Explain the ISA and HASA class relationships. How would you implement each in a class design?
  A specialized class "is" a specialization of another class and, therefore, has the ISA relationship with the other class. An Employee ISA Person. This relationship is best implemented with inheritance. Employee is derived from Person. A class may have an instance of another class. For example, an employee "has" a salary, therefore the Employee class has the HASA relationship with the Salary class. This relationship is best implemented by embedding an object of the Salary class in the Employee class.
• When is a template a better solution than a base class?
  When you are designing a generic class to contain or otherwise manage objects of other types, when the format and behavior of those other types are unimportant to their containment or management, and particularly when those other types are unknown (thus, the generosity) to the designer of the container or manager class.
• What is a mutable member?
  One that can be modified by the class even when the object of the class or the member function doing the modification is const.
• What is an explicit constructor?
  A conversion constructor declared with the explicit keyword. The compiler does not use an explicit constructor to implement an implied conversion of types. It’s purpose is reserved explicitly for construction.
• 
  
• 
  
• What is the Standard Template Library (STL)?
  A library of container templates approved by the ANSI committee for inclusion in the standard C++ specification.
  A programmer who then launches into a discussion of the generic programming model, iterators, allocators, algorithms, and such, has a higher than average understanding of the new technology that STL brings to C++ programming.
• Describe run-time type identification.
  The ability to determine at run time the type of an object by using the typeid operator or the dynamic_cast operator.
• What problem does the namespace feature solve?
  Multiple providers of libraries might use common global identifiers causing a name collision when an application tries to link with two or more such libraries. The namespace feature surrounds a library’s external declarations with a unique namespace that eliminates the potential for those collisions.
  This solution assumes that two library vendors don’t use the same namespace identifier, of course.
• Are there any new intrinsic (built-in) data types?
  Yes. The ANSI committee added the bool intrinsic type and its true and false value keywords.
• Will the following program execute?
  void main()
  {
  void *vptr = (void *) malloc(sizeof(void));
  vptr++;
  }
  
  Answer1
  It will throw an error, as arithmetic operations cannot be performed on void pointers.
  
  Answer2
  It will not build as sizeof cannot be applied to void* ( error “Unknown size” )
  
  Answer3
  How can it execute if it won’t even compile? It needs to be int main, not void main. Also, cannot increment a void *.
  
  Answer4
  According to gcc compiler it won’t show any error, simply it executes. but in general we can’t do arthematic operation on void, and gives size of void as 1
  
  Answer5
  The program compiles in GNU C while giving a warning for “void main”. The program runs without a crash. sizeof(void) is “1? hence when vptr++, the address is incremented by 1.
  
  Answer6
  Regarding arguments about GCC, be aware that this is a C++ question, not C. So gcc will compile and execute, g++ cannot. g++ complains that the return type cannot be void and the argument of sizeof() cannot be void. It also reports that ISO C++ forbids incrementing a pointer of type ‘void*’.
  
  Answer7
  in C++
  voidp.c: In function `int main()’:
  voidp.c:4: error: invalid application of `sizeof’ to a void type
  voidp.c:4: error: `malloc’ undeclared (first use this function)
  voidp.c:4: error: (Each undeclared identifier is reported only once for each function it appears in.)
  voidp.c:6: error: ISO C++ forbids incrementing a pointer of type `void*’
  
  But in c, it work without problems
• void main()
  {
  char *cptr = 0?2000;
  long *lptr = 0?2000;
  cptr++;
  lptr++;
  printf(” %x %x”, cptr, lptr);
  }
  Will it execute or not?
  Answer1
  For Q2: As above, won’t compile because main must return int. Also, 0×2000 cannot be implicitly converted to a pointer (I assume you meant 0×2000 and not 0?2000.)
  
  Answer2
  Not Excute.
  Compile with VC7 results following errors:
  error C2440: ‘initializing’ : cannot convert from ‘int’ to ‘char *’
  error C2440: ‘initializing’ : cannot convert from ‘int’ to ‘long *’
  
  
  Not Excute if it is C++, but Excute in C.
  The printout:
  2001 2004
  
  Answer3
  In C++
  [$]> g++ point.c
  point.c: In function `int main()’:
  point.c:4: error: invalid conversion from `int’ to `char*’
  point.c:5: error: invalid conversion from `int’ to `long int*’
  
  in C
  ———————————–
  [$] etc > gcc point.c
  point.c: In function `main’:
  point.c:4: warning: initialization makes pointer from integer without a cast
  point.c:5: warning: initialization makes pointer from integer without a cast
  [$] etc > ./a.exe
  2001 2004
• 
  
• What is the difference between Mutex and Binary semaphore?
  semaphore is used to synchronize processes. where as mutex is used to provide synchronization between threads running in the same process.
• In C++, what is the difference between method overloading and method overriding?
  Overloading a method (or function) in C++ is the ability for functions of the same name to be defined as long as these methods have different signatures (different set of parameters). Method overriding is the ability of the inherited class rewriting the virtual method of the base class.
• What methods can be overridden in Java?
  In C++ terminology, all public methods in Java are virtual. Therefore, all Java methods can be overwritten in subclasses except those that are declared final, static, and private.
• What are the defining traits of an object-oriented language?
  The defining traits of an object-oriented langauge are:
  * encapsulation
  * inheritance
  * polymorphism
• Write a program that ask for user input from 5 to 9 then calculate the average
  int main()
  {
  int MAX=4;
  int total =0;
  int average=0;
  int numb;
  cout<<"Please enter your input from 5 to 9";
  cin>>numb;
  if((numb <5)&&(numb>9))
  cout<<"please re type your input";
  else
  for(i=0;i<=MAX; i++)
  {
  total = total + numb;
  average= total /MAX;
  }
  cout<<"The average number is"<<average<<endl;
  
  return 0;
  }
• Assignment Operator - What is the diffrence between a "assignment operator" and a "copy constructor"?
  Answer1.
  In assignment operator, you are assigning a value to an existing object. But in copy constructor, you are creating a new object and then assigning a value to that object. For example:
  complex c1,c2;
  c1=c2; //this is assignment
  complex c3=c2; //copy constructor
  
  Answer2.
  A copy constructor is used to initialize a newly declared variable from an existing variable. This makes a deep copy like assignment, but it is somewhat simpler:
  
  There is no need to test to see if it is being initialized from itself.
  There is no need to clean up (eg, delete) an existing value (there is none).
  A reference to itself is not returned.
• RTTI - What is RTTI?
  Answer1.
  RTTI stands for "Run Time Type Identification". In an inheritance hierarchy, we can find out the exact type of the objet of which it is member. It can be done by using:
  
  1) dynamic id operator
  2) typecast operator
  
  Answer2.
  RTTI is defined as follows: Run Time Type Information, a facility that allows an object to be queried at runtime to determine its type. One of the fundamental principles of object technology is polymorphism, which is the ability of an object to dynamically change at runtime.
• STL Containers - What are the types of STL containers?
  There are 3 types of STL containers:
  
  1. Adaptive containers like queue, stack
  2. Associative containers like set, map
  3. Sequence containers like vector, deque
• What is the need for a Virtual Destructor ?
  Destructors are declared as virtual because if do not declare it as virtual the base class destructor will be called before the derived class destructor and that will lead to memory leak because derived class’s objects will not get freed.Destructors are declared virtual so as to bind objects to the methods at runtime so that appropriate destructor is called.
• 
  
• What is "mutable"?
  Answer1.
  "mutable" is a C++ keyword. When we declare const, none of its data members can change. When we want one of its members to change, we declare it as mutable.
  
  Answer2.
  A "mutable" keyword is useful when we want to force a "logical const" data member to have its value modified. A logical const can happen when we declare a data member as non-const, but we have a const member function attempting to modify that data member. For example:
  class Dummy {
  public:
  bool isValid() const;
  private:
  mutable int size_ = 0;
  mutable bool validStatus_ = FALSE;
  // logical const issue resolved
  };
  
  bool Dummy::isValid() const
  // data members become bitwise const
  {
  if (size > 10) {
  validStatus_ = TRUE; // fine to assign
  size = 0; // fine to assign
  }
  }
  
  
  Answer2.
  "mutable" keyword in C++ is used to specify that the member may be updated or modified even if it is member of constant object. Example:
  class Animal {
  private:
  string name;
  string food;
  mutable int age;
  public:
  void set_age(int a);
  };
  
  void main() {
  const Animal Tiger(’Fulffy’,'antelope’,1);
  Tiger.set_age(2);
  // the age can be changed since its mutable
  }
• Differences of C and C++
  Could you write a small program that will compile in C but not in C++ ?
  In C, if you can a const variable e.g.
  const int i = 2;
  you can use this variable in other module as follows
  extern const int i;
  C compiler will not complain.
  
  But for C++ compiler u must write
  extern const int i = 2;
  else error would be generated.
• Bitwise Operations - Given inputs X, Y, Z and operations | and & (meaning bitwise OR and AND, respectively), what is output equal to in?
  output = (X & Y) | (X & Z) | (Y & Z);
• 
  

• C++ Object-Oriented Interview Questions And Answers

• What is a modifier?
  A modifier, also called a modifying function is a member function that changes the value of  at least one data member. In other words, an operation that modifies the state of an object. Modifiers are also known as ‘mutators’. Example: The function mod is a modifier in the following code snippet:
  
  class test
  {
  int x,y;
  public:
  test()
  {
  x=0; y=0;
  }
  void mod()
  {
  x=10;
  y=15;
  }
  };
• What is an accessor?
  An accessor is a class operation that does not modify the state of an object. The accessor functions need to be declared as const operations
• 
  
• Differentiate between a template class and class template.
  Template class: A generic definition or a parameterized class not instantiated until the client provides the needed information. It’s jargon for plain templates. Class template: A class template specifies how individual classes can be constructed much like the way a class specifies how individual objects can be constructed. It’s jargon for plain classes.
• When does a name clash occur?
  A name clash occurs when a name is defined in more than one place. For example., two different class libraries could give two different classes the same name. If you try to use many class libraries at the same time, there is a fair chance that you will be unable to compile or link the program because of name clashes.
• Define namespace.
  It is a feature in C++ to minimize name collisions in the global name space. This namespace keyword assigns a distinct name to a library that allows other libraries to use the same identifier names without creating any name collisions. Furthermore, the compiler uses the namespace signature for differentiating the definitions.
• What is the use of ‘using’ declaration. ?
  A using declaration makes it possible to use a name from a namespace without the scope operator.
• What is an Iterator class ?
  A class that is used to traverse through the objects maintained by a container class. There are five categories of iterators: input iterators, output iterators, forward iterators, bidirectional iterators, random access. An iterator is an entity that gives access to the contents of a container object without violating encapsulation constraints. Access to the contents is granted on a one-at-a-time basis in order. The order can be storage order (as in lists and queues) or some arbitrary order (as in array indices) or according to some ordering relation (as in an ordered binary tree). The iterator is a construct, which provides an interface that, when called, yields either the next element in the container, or some value denoting the fact that there are no more elements to examine. Iterators hide the details of access to and update of the elements of a container class.
  The simplest and safest iterators are those that permit read-only access to the contents of a container class.
• What is an incomplete type?
  Incomplete types refers to pointers in which there is non availability of the implementation of the referenced location or it points to some location whose value is not available for modification.
  
  int *i=0x400 // i points to address 400
  *i=0; //set the value of memory location pointed by i.
  
  Incomplete types are otherwise called uninitialized pointers.
• What is a dangling pointer?
  A dangling pointer arises when you use the address of an object after
  its lifetime is over. This may occur in situations like returning
  addresses of the automatic variables from a function or using the
  address of the memory block after it is freed. The following
  code snippet shows this:
  
  class Sample
  {
  public:
  int *ptr;
  Sample(int i)
  {
  ptr = new int(i);
  }
  
  ~Sample()
  {
  delete ptr;
  }
  void PrintVal()
  {
  cout << "The value is " << *ptr;
  }
  };
  
  void SomeFunc(Sample x)
  {
  cout << "Say i am in someFunc " << endl;
  }
  
  int main()
  {
  Sample s1 = 10;
  SomeFunc(s1);
  s1.PrintVal();
  }
  
  In the above example when PrintVal() function is
  called it is called by the pointer that has been freed by the
  destructor in SomeFunc.
• 
  
• Differentiate between the message and method.
  Message:
  * Objects communicate by sending messages to each other.
  * A message is sent to invoke a method.
  
  Method
  * Provides response to a message.
  * It is an implementation of an operation.
• What is an adaptor class or Wrapper class?
  A class that has no functionality of its own. Its member functions hide the use of a third party software component or an object with the non-compatible interface or a non-object-oriented implementation.
• What is a Null object?
  It is an object of some class whose purpose is to indicate that a real object of that class does not exist. One common use for a null object is a return value from a member function that is supposed to return an object with some specified properties but cannot find such an object.
• What is class invariant?
  A class invariant is a condition that defines all valid states for an object. It is a logical condition to ensure the correct working of a class. Class invariants must hold when an object is created, and they must be preserved under all operations of the class. In particular all class invariants are both preconditions and post-conditions for all operations or member functions of the class.
• What do you mean by Stack unwinding?
  It is a process during exception handling when the destructor is called for all local objects between the place where the exception was thrown and where it is caught.
• Define precondition and post-condition to a member function.
  Precondition: A precondition is a condition that must be true on entry to a member function. A class is used correctly if preconditions are never false. An operation is not responsible for doing anything sensible if its precondition fails to hold. For example, the interface invariants of stack class say nothing about pushing yet another element on a stack that is already full. We say that isful() is a precondition of the push operation. Post-condition: A post-condition is a condition that must be true on exit from a member function if the precondition was valid on entry to that function. A class is implemented correctly if post-conditions are never false. For example, after pushing an element on the stack, we know that isempty() must necessarily hold. This is a post-condition of the push operation.
• What are the conditions that have to be met for a condition to be an invariant of the class?
  * The condition should hold at the end of every constructor.
  * The condition should hold at the end of every mutator (non-const) operation.
• What are proxy objects?
  Objects that stand for other objects are called proxy objects or surrogates.
  template <class t="">
  class Array2D
  {
  public:
  class Array1D
  {
  public:
  T& operator[] (int index);
  const T& operator[] (int index)const;
  };
  
  Array1D operator[] (int index);
  const Array1D operator[] (int index) const;
  };
  
  The following then becomes legal:
  
  Array2D<float>data(10,20);
  cout<<data[3][6]; // fine
  
  Here data[3] yields an Array1D object and the operator [] invocation on that object yields the float in position(3,6) of the original two dimensional array. Clients of the Array2D class need not be aware of the presence of the Array1D class. Objects of this latter class stand for one-dimensional array objects that, conceptually, do not exist for clients of Array2D. Such clients program as if they were using real, live, two-dimensional arrays. Each Array1D object stands for a one-dimensional array that is absent from a conceptual model used by the clients of Array2D. In the above example, Array1D is a proxy class. Its instances stand for one-dimensional arrays that, conceptually, do not exist.
• Name some pure object oriented languages.
  Smalltalk, Java, Eiffel, Sather.
• What is an orthogonal base class?
  If two base classes have no overlapping methods or data they are said to be independent of, or orthogonal to each other. Orthogonal in the sense means that two classes operate in different dimensions and do not interfere with each other in any way. The same derived class may inherit such classes with no difficulty.
• 
  
• What is a node class?
  A node class is a class that,
  * relies on the base class for services and implementation,
  * provides a wider interface to the users than its base class,
  * relies primarily on virtual functions in its public interface
  * depends on all its direct and indirect base class
  * can be understood only in the context of the base class
  * can be used as base for further derivation
  * can be used to create objects.
  A node class is a class that has added new services or functionality beyond the services inherited from its base class.
• What is a container class? What are the types of container classes?
  A container class is a class that is used to hold objects in memory or external storage. A container class acts as a generic holder. A container class has a predefined behavior and a well-known interface. A container class is a supporting class whose purpose is to hide the topology used for maintaining the list of objects in memory. When a container class contains a group of mixed objects, the container is called a heterogeneous container; when the container is holding a group of objects that are all the same, the container is called a homogeneous container.
• How do you write a function that can reverse a linked-list?
  Answer1:
  
  void reverselist(void)
  {
  if(head==0)
  return;
  if(head-<next==0)
  return;
  if(head-<next==tail)
  {
  head-<next = 0;
  tail-<next = head;
  }
  else
  {
  node* pre = head;
  node* cur = head-<next;
  node* curnext = cur-<next;
  head-<next = 0;
  cur-<next = head;
  
  for(; curnext!=0; )
  {
  cur-<next = pre;
  pre = cur;
  cur = curnext;
  curnext = curnext-<next;
  }
  
  curnext-<next = cur;
  }
  }
  
  Answer2:
  
  node* reverselist(node* head)
  {
  if(0==head || 0==head->next)
  //if head->next ==0 should return head instead of 0;
  return 0;
  
  {
  node* prev = head;
  node* curr = head->next;
  node* next = curr->next;
  
  for(; next!=0; )
  {
  curr->next = prev;
  prev = curr;
  curr = next;
  next = next->next;
  }
  curr->next = prev;
  
  head->next = 0;
  head = curr;
  }
  
  return head;
  }
• What is polymorphism?
  Polymorphism is the idea that a base class can be inherited by several classes. A base class pointer can point to its child class and a base class array can store different child class objects.
• How do you find out if a linked-list has an end? (i.e. the list is not a cycle)
  You can find out by using 2 pointers. One of them goes 2 nodes each time. The second one goes at 1 nodes each time. If there is a cycle, the one that goes 2 nodes each time will eventually meet the one that goes slower. If that is the case, then you will know the linked-list is a cycle.
• 
  
• How can you tell what shell you are running on UNIX system?
  You can do the Echo $RANDOM. It will return a undefined variable if you are from the C-Shell, just a return prompt if you are from the Bourne shell, and a 5 digit random numbers if you are from the Korn shell. You could also do a ps -l and look for the shell with the highest PID.
• What is Boyce Codd Normal form?
  A relation schema R is in BCNF with respect to a set F of functional dependencies if for all functional dependencies in F+ of the form a->b, where a and b is a subset of R, at least one of the following holds:
  
  * a->b is a trivial functional dependency (b is a subset of a)
  * a is a superkey for schema R
• What is pure virtual function?
  A class is made abstract by declaring one or more of its virtual functions to be pure. A pure virtual function is one with an initializer of = 0 in its declaration
• Write a Struct Time where integer m, h, s are its members
  struct Time
  {
  int m;
  int h;
  int s;
  };
• How do you traverse a Btree in Backward in-order?
  Process the node in the right subtree
  Process the root
  Process the node in the left subtree
• What is the two main roles of Operating System?
  As a resource manager
  As a virtual machine
• In the derived class, which data member of the base class are visible?
  In the public and protected sections.

• C++ programming on UNIX

• Could you tell something about the Unix System Kernel?
  The kernel is the heart of the UNIX openrating system, it’s reponsible for controlling the computer’s resouces and scheduling user jobs so that each one gets its fair share of resources.
• What are each of the standard files and what are they normally associated with?
  They are the standard input file, the standard output file and the standard error file. The first is usually associated with the keyboard, the second and third are usually associated with the terminal screen.
• Detemine the code below, tell me exectly how many times is the operation sum++ performed ?
  for ( i = 0; i < 100; i++ )
  for ( j = 100; j > 100 - i; j–)
  sum++;
  
  (99 * 100)/2 = 4950
  The sum++ is performed 4950 times.
• Give 4 examples which belongs application layer in TCP/IP architecture?
  FTP, TELNET, HTTP and TFTP
• What’s the meaning of ARP in TCP/IP?
  The "ARP" stands for Address Resolution Protocol. The ARP standard defines two basic message types: a request and a response. a request message contains an IP address and requests the corresponding hardware address; a replay contains both the IP address, sent in the request, and the hardware address.
• What is a Makefile?
  Makefile is a utility in Unix to help compile large programs. It helps by only compiling the portion of the program that has been changed.
  A Makefile is the file and make uses to determine what rules to apply. make is useful for far more than compiling programs.
• What is deadlock?
  Deadlock is a situation when two or more processes prevent each other from running. Example: if T1 is holding x and waiting for y to be free and T2 holding y and waiting for x to be free deadlock happens.
• 
  
• What is semaphore?
  Semaphore is a special variable, it has two methods: up and down. Semaphore performs atomic operations, which means ones a semaphore is called it can not be inturrupted.
  
  The internal counter (= #ups - #downs) can never be negative. If you execute the “down” method when the internal counter is zero, it will block until some other thread calls the “up” method. Semaphores are use for thread synchronization.
• Is C an object-oriented language?
  C is not an object-oriented language, but limited object-oriented programming can be done in C.
• 
  
• Name some major differences between C++ and Java.
  C++ has pointers; Java does not. Java is platform-independent; C++ is not. Java has garbage collection; C++ does not. Java does have pointers. In fact all variables in Java are pointers. The difference is that Java does not allow you to manipulate the addresses of the pointer

• 
  C++ Networking Interview Questions and Answers 

• What is the difference between Stack and Queue?
  Stack is a Last In First Out (LIFO) data structure.
  Queue is a First In First Out (FIFO) data structure
• Write a fucntion that will reverse a string.
  char *strrev(char *s)
  {
  int i = 0, len = strlen(s);
  char *str;
  if ((str = (char *)malloc(len+1)) == NULL)
  /*cannot allocate memory */
  err_num = 2;
  return (str);
  }
  while(len)
  str[i++]=s[–len];
  str[i] = NULL;
  return (str);
  }
• What is the software Life-Cycle?
  The software Life-Cycle are
  1) Analysis and specification of the task
  2) Design of the algorithms and data structures
  3) Implementation (coding)
  4) Testing
  5) Maintenance and evolution of the system
  6) Obsolescence
• What is the difference between a Java application and a Java applet?
  The difference between a Java application and a Java applet is that a Java application is a program that can be executed using the Java interpeter, and a JAVA applet can be transfered to different networks and executed by using a web browser (transferable to the WWW).
• Name 7 layers of the OSI Reference Model?
  -Application layer
  -Presentation layer
  -Session layer
  -Transport layer
  -Network layer
  -Data Link layer
  -Physical layer

• C++ Algorithm Interview Questions and Answers
   

• What are the advantages and disadvantages of B-star trees over Binary trees?
  
  Answer1
  B-star trees have better data structure and are faster in search than Binary trees, but it’s harder to write codes for B-start trees.
  
  Answer2
  The major difference between B-tree and binary tres is that B-tree is a external data structure and binary tree is a main memory data structure. The computational complexity of binary tree is counted by the number of comparison operations at each node, while the computational complexity of B-tree is determined by the disk I/O, that is, the number of node that will be loaded from disk to main memory. The comparision of the different values in one node is not counted.
  
  
  Write the psuedo code for the Depth first Search.
  
  dfs(G, v) //OUTLINE
  Mark v as "discovered"
  For each vertex w such that edge vw is in G:
  If w is undiscovered:
  dfs(G, w); that is, explore vw, visit w, explore from there as much as possible, and backtrack from w to v. Otherwise:
  "Check" vw without visiting w. Mark v as "finished".
  
  
  Describe one simple rehashing policy.
  
  The simplest rehashing policy is linear probing. Suppose a key K hashes to location i. Suppose other key occupies H[i]. The following function is used to generate alternative locations:
  rehash(j) = (j + 1) mod h
  where j is the location most recently probed. Initially j = i, the hash code for K. Notice that this version of rehash does not depend on K.
  
  
  Describe Stacks and name a couple of places where stacks are useful.
  
  A Stack is a linear structure in which insertions and deletions are always made at one end, called the top. This updating policy is called last in, first out (LIFO). It is useful when we need to check some syntex errors, such as missing parentheses.
  
  
  Suppose a 3-bit sequence number is used in the selective-reject ARQ, what is the maximum number of frames that could be transmitted at a time?
  
  If a 3-bit sequence number is used, then it could distinguish 8 different frames. Since the number of frames that could be transmitted at a time is no greater half the numner of frames that could be distinguished by the sequence number, so at most 4 frames can be transmitted at a time.

• What is Python?
  Python is an interpreted, interactive, object-oriented programming language. It incorporates modules, exceptions, dynamic typing, very high level dynamic data types, and classes. Python combines remarkable power with very clear syntax. It has interfaces to many system calls and libraries, as well as to various window systems, and is extensible in C or C++. It is also usable as an extension language for applications that need a programmable interface. Finally, Python is portable: it runs on many Unix variants, on the Mac, and on PCs under MS-DOS, Windows, Windows NT, and OS/2.
• Why can't I use an assignment in an expression?
• Many people used to C or Perl complain that they want to use this C idiom:
• 
  
• while (line = readline(f)) {
• ...do something with line...
• }
• 
  
• where in Python you're forced to write this:
• 
  
• while True:
• line = f.readline()
• if not line:
• break
• ...do something with line...
• 
  
• The reason for not allowing assignment in Python expressions is a common, hard-to-find bug in those other languages, caused by this construct:
• 
  
• if (x = 0) {
• ...error handling...
• }
• else {
• ...code that only works for nonzero x...
• }
• 
  
• The error is a simple typo: x = 0, which assigns 0 to the variable x, was written while the comparison x == 0 is certainly what was intended.
• Many alternatives have been proposed. Most are hacks that save some typing but use arbitrary or cryptic syntax or keywords, and fail the simple criterion for language change proposals: it should intuitively suggest the proper meaning to a human reader who has not yet been introduced to the construct.
• An interesting phenomenon is that most experienced Python programmers recognize the "while True" idiom and don't seem to be missing the assignment in expression construct much; it's only newcomers who express a strong desire to add this to the language.
• There's an alternative way of spelling this that seems attractive but is generally less robust than the "while True" solution:
• line = f.readline()
• while line:
• ...do something with line...
• line = f.readline()
• The problem with this is that if you change your mind about exactly how you get the next line (e.g. you want to change it into sys.stdin.readline()) you have to remember to change two places in your program -- the second occurrence is hidden at the bottom of the loop.
• The best approach is to use iterators, making it possible to loop through objects using the for statement. For example, in the current version of Python file objects support the iterator protocol, so you can now write simply:
• for line in f:
• ... do something with line...
• Is there a tool to help find bugs or perform static analysis?
• Yes.
• PyChecker is a static analysis tool that finds bugs in Python source code and warns about code complexity and style.
• 
  
• Pylint is another tool that checks if a module satisfies a coding standard, and also makes it possible to write plug-ins to add a custom feature.
• How do you set a global variable in a function?
• Did you do something like this?
• x = 1 # make a global
• def f():
• print x # try to print the global
• ...
• for j in range(100):
• if q>3:
• x=4
• 
  
• Any variable assigned in a function is local to that function. unless it is specifically declared global. Since a value is bound to x as the last statement of the function body, the compiler assumes that x is local. Consequently the print x attempts to print an uninitialized local variable and will trigger a NameError.
• The solution is to insert an explicit global declaration at the start of the function:
• def f():
• global x
• print x # try to print the global
• ...
• for j in range(100):
• if q>3:
• x=4
• 
  
• In this case, all references to x are interpreted as references to the x from the module namespace.
• What are the rules for local and global variables in Python?
• In Python, variables that are only referenced inside a function are implicitly global. If a variable is assigned a new value anywhere within the function's body, it's assumed to be a local. If a variable is ever assigned a new value inside the function, the variable is implicitly local, and you need to explicitly declare it as 'global'.
• Though a bit surprising at first, a moment's consideration explains this. On one hand, requiring global for assigned variables provides a bar against unintended side-effects. On the other hand, if global was required for all global references, you'd be using global all the time. You'd have to declare as global every reference to a builtin function or to a component of an imported module. This clutter would defeat the usefulness of the global declaration for identifying side-effects.
• How do I share global variables across modules?
• The canonical way to share information across modules within a single program is to create a special module (often called config or cfg). Just import the config module in all modules of your application; the module then becomes available as a global name. Because there is only one instance of each module, any changes made to the module object get reflected everywhere. For example:
• 
  
• config.py:
• x = 0 # Default value of the 'x' configuration setting
• mod.py:
• import config
• config.x = 1
• 
  
• main.py:
• import config
• import mod
• print config.x
• 
  
• Note that using a module is also the basis for implementing the Singleton design pattern, for the same reason.
• 
  
• 
  

• Python Interview Questions and Answers

• How can I pass optional or keyword parameters from one function to another?
  Collect the arguments using the * and ** specifier in the function's parameter list; this gives you the positional arguments as a tuple and the keyword arguments as a dictionary. You can then pass these arguments when calling another function by using * and **:
• 
  
• def f(x, *tup, **kwargs):
• ...
• kwargs['width']='14.3c'
• ...
• g(x, *tup, **kwargs)
• 
  
• In the unlikely case that you care about Python versions older than 2.0, use 'apply':
• 
  
• def f(x, *tup, **kwargs):
• ...
• kwargs['width']='14.3c'
• ...
• apply(g, (x,)+tup, kwargs)
• How do you make a higher order function in Python?
  You have two choices: you can use nested scopes or you can use callable objects. For example, suppose you wanted to define linear(a,b) which returns a function f(x) that computes the value a*x+b. Using nested scopes:
• 
  
• def linear(a,b):
• def result(x):
• return a*x + b
• return result
• 
  
• Or using a callable object:
• 
  
• class linear:
• def __init__(self, a, b):
• self.a, self.b = a,b
• def __call__(self, x):
• return self.a * x + self.b
• 
  
• In both cases:
• 
  
• taxes = linear(0.3,2)
• 
  
• gives a callable object where taxes(10e6) == 0.3 * 10e6 + 2.
• 
  
• The callable object approach has the disadvantage that it is a bit slower and results in slightly longer code. However, note that a collection of callables can share their signature via inheritance:
• 
  
• class exponential(linear):
• # __init__ inherited
• def __call__(self, x):
• return self.a * (x ** self.b)
• Object can encapsulate state for several methods:
• 
  
• class counter:
• value = 0
• def set(self, x): self.value = x
• def up(self): self.value=self.value+1
• def down(self): self.value=self.value-1
• 
  
• count = counter()
• inc, dec, reset = count.up, count.down, count.set
• 
  
• 
  
• Here inc(), dec() and reset() act like functions which share the same counting variable.
• How do I copy an object in Python?
• In general, try copy.copy() or copy.deepcopy() for the general case. Not all objects can be copied, but most can.
• 
  
• Some objects can be copied more easily. Dictionaries have a copy() method:
• 
  
• newdict = olddict.copy()
• 
  
• Sequences can be copied by slicing:
• 
  
• new_l = l[:]
• How can I find the methods or attributes of an object?
• For an instance x of a user-defined class, dir(x) returns an alphabetized list of the names containing the instance attributes and methods and attributes defined by its class.
• How do I convert a string to a number?
• For integers, use the built-in int() type constructor, e.g. int('144') == 144. Similarly, float() converts to floating-point, e.g. float('144') == 144.0.
• 
  
• By default, these interpret the number as decimal, so that int('0144') == 144 and int('0x144') raises ValueError. int(string, base) takes the base to convert from as a second optional argument, so int('0x144', 16) == 324. If the base is specified as 0, the number is interpreted using Python's rules: a leading '0' indicates octal, and '0x' indicates a hex number.
• 
  
• Do not use the built-in function eval() if all you need is to convert strings to numbers. eval() will be significantly slower and it presents a security risk: someone could pass you a Python expression that might have unwanted side effects. For example, someone could pass __import__('os').system("rm -rf $HOME") which would erase your home directory.
• 
  
• eval() also has the effect of interpreting numbers as Python expressions, so that e.g. eval('09') gives a syntax error because Python regards numbers starting with '0' as octal (base 8).
• 
  
• How can my code discover the name of an object?
  Generally speaking, it can't, because objects don't really have names. Essentially, assignment always binds a name to a value; The same is true of def and class statements, but in that case the value is a callable. Consider the following code:
• 
  
• class A:
• pass
• 
  
• B = A
• 
  
• a = B()
• b = a
• print b
• <__main__.A instance at 016D07CC>
• print a
• <__main__.A instance at 016D07CC>
• 
  
• Arguably the class has a name: even though it is bound to two names and invoked through the name B the created instance is still reported as an instance of class A. However, it is impossible to say whether the instance's name is a or b, since both names are bound to the same value.
• 
  
• Generally speaking it should not be necessary for your code to "know the names" of particular values. Unless you are deliberately writing introspective programs, this is usually an indication that a change of approach might be beneficial.
• 
  
• In comp.lang.python, Fredrik Lundh once gave an excellent analogy in answer to this question:
• 
  
• The same way as you get the name of that cat you found on your porch: the cat (object) itself cannot tell you its name, and it doesn't really care -- so the only way to find out what it's called is to ask all your neighbours (namespaces) if it's their cat (object)...
• 
  
• ....and don't be surprised if you'll find that it's known by many names, or no name at all!
• Is there an equivalent of C's "?:" ternary operator?
• No.
• How do I convert a number to a string?
• To convert, e.g., the number 144 to the string '144', use the built-in function str(). If you want a hexadecimal or octal representation, use the built-in functions hex() or oct(). For fancy formatting, use the % operator on strings, e.g. "%04d" % 144 yields '0144' and "%.3f" % (1/3.0) yields '0.333'. See the library reference manual for details.
• How do I modify a string in place?
• You can't, because strings are immutable. If you need an object with this ability, try converting the string to a list or use the array module:
• 
  
• >>> s = "Hello, world"
• >>> a = list(s)
• >>>print a
• ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd']
• >>> a[7:] = list("there!")
• >>>''.join(a)
• 'Hello, there!'
• 
  
• 
  
• >>> import array
• >>> a = array.array('c', s)
• >>> print a
• array('c', 'Hello, world')
• >>> a[0] = 'y' ; print a
• array('c', 'yello world')
• >>> a.tostring()
• 'yello, world'
• How do I use strings to call functions/methods?
  There are various techniques.
• 
  
• * The best is to use a dictionary that maps strings to functions. The primary advantage of this technique is that the strings do not need to match the names of the functions. This is also the primary technique used to emulate a case construct:
• 
  
• def a():
• pass
• 
  
• def b():
• pass
• 
  
• dispatch = {'go': a, 'stop': b} # Note lack of parens for funcs
• 
  
• dispatch[get_input()]() # Note trailing parens to call function
• *
• Use the built-in function getattr():
• 
  
• import foo
• getattr(foo, 'bar')()
• 
  
• Note that getattr() works on any object, including classes, class instances, modules, and so on.
• 
  
• This is used in several places in the standard library, like this:
• 
  
• class Foo:
• def do_foo(self):
• ...
• def do_bar(self):
• ...
• 
  
• f = getattr(foo_instance, 'do_' + opname)
• f()
• 
  
• *
• Use locals() or eval() to resolve the function name:
• 
  
• def myFunc():
• print "hello"
• 
  
• fname = "myFunc"
• 
  
• f = locals()[fname]
• f()
• 
  
• f = eval(fname)
• f()
• 
  
• Note: Using eval() is slow and dangerous. If you don't have absolute control over the contents of the string, someone could pass a string that resulted in an arbitrary function being executed.
• Is there an equivalent to Perl's chomp() for removing trailing newlines from strings?
• Starting with Python 2.2, you can use S.rstrip("\r\n") to remove all occurences of any line terminator from the end of the string S without removing other trailing whitespace. If the string S represents more than one line, with several empty lines at the end, the line terminators for all the blank lines will be removed:
• 
  
• >>> lines = ("line 1 \r\n"
• ... "\r\n"
• ... "\r\n")
• >>> lines.rstrip("\n\r")
• "line 1 "
• 
  
• Since this is typically only desired when reading text one line at a time, using S.rstrip() this way works well.
• 
  
• For older versions of Python, There are two partial substitutes:
• 
  
• * If you want to remove all trailing whitespace, use the rstrip() method of string objects. This removes all trailing whitespace, not just a single newline.
• * Otherwise, if there is only one line in the string S, use S.splitlines()[0].
• 
  
• Is there a scanf() or sscanf() equivalent?
  Not as such.
• 
  
• For simple input parsing, the easiest approach is usually to split the line into whitespace-delimited words using the split() method of string objects and then convert decimal strings to numeric values using int() or float(). split() supports an optional "sep" parameter which is useful if the line uses something other than whitespace as a separator.
• 
  
• For more complicated input parsing, regular expressions more powerful than C's sscanf() and better suited for the task.
• Is there a scanf() or sscanf() equivalent?
• 
  
• Not as such.
• 
  
• For simple input parsing, the easiest approach is usually to split the line into whitespace-delimited words using the split() method of string objects and then convert decimal strings to numeric values using int() or float(). split() supports an optional "sep" parameter which is useful if the line uses something other than whitespace as a separator.
• 
  
• For more complicated input parsing, regular expressions more powerful than C's sscanf() and better suited for the task. 1.3.9 What does 'UnicodeError: ASCII [decoding,encoding] error: ordinal not in range(128)' mean?
• 
  
• This error indicates that your Python installation can handle only 7-bit ASCII strings. There are a couple ways to fix or work around the problem.
• 
  
• If your programs must handle data in arbitrary character set encodings, the environment the application runs in will generally identify the encoding of the data it is handing you. You need to convert the input to Unicode data using that encoding. For example, a program that handles email or web input will typically find character set encoding information in Content-Type headers. This can then be used to properly convert input data to Unicode. Assuming the string referred to by value is encoded as UTF-8:
• 
  
• value = unicode(value, "utf-8")
• 
  
• will return a Unicode object. If the data is not correctly encoded as UTF-8, the above call will raise a UnicodeError exception.
• 
  
• If you only want strings converted to Unicode which have non-ASCII data, you can try converting them first assuming an ASCII encoding, and then generate Unicode objects if that fails:
• 
  
• try:
• x = unicode(value, "ascii")
• except UnicodeError:
• value = unicode(value, "utf-8")
• else:
• # value was valid ASCII data
• pass
• 
  
• It's possible to set a default encoding in a file called sitecustomize.py that's part of the Python library. However, this isn't recommended because changing the Python-wide default encoding may cause third-party extension modules to fail.
• 
  
• Note that on Windows, there is an encoding known as "mbcs", which uses an encoding specific to your current locale. In many cases, and particularly when working with COM, this may be an appropriate default encoding to use.
• How do I convert between tuples and lists?
• The function tuple(seq) converts any sequence (actually, any iterable) into a tuple with the same items in the same order.
• 
  
• For example, tuple([1, 2, 3]) yields (1, 2, 3) and tuple('abc') yields ('a', 'b', 'c'). If the argument is a tuple, it does not make a copy but returns the same object, so it is cheap to call tuple() when you aren't sure that an object is already a tuple.
• 
  
• The function list(seq) converts any sequence or iterable into a list with the same items in the same order. For example, list((1, 2, 3)) yields [1, 2, 3] and list('abc') yields ['a', 'b', 'c']. If the argument is a list, it makes a copy just like seq[:] would.
• What's a negative index?
• Python sequences are indexed with positive numbers and negative numbers. For positive numbers 0 is the first index 1 is the second index and so forth. For negative indices -1 is the last index and -2 is the penultimate (next to last) index and so forth. Think of seq[-n] as the same as seq[len(seq)-n].
• 
  
• Using negative indices can be very convenient. For example S[:-1] is all of the string except for its last character, which is useful for removing the trailing newline from a string.
• How do I iterate over a sequence in reverse order?
  If it is a list, the fastest solution is
• 
  
• list.reverse()
• try:
• for x in list:
• "do something with x"
• finally:
• list.reverse()
• 
  
• This has the disadvantage that while you are in the loop, the list is temporarily reversed. If you don't like this, you can make a copy. This appears expensive but is actually faster than other solutions:
• 
  
• rev = list[:]
• rev.reverse()
• for x in rev:
• <do something with x>
• 
  
• If it's not a list, a more general but slower solution is:
• 
  
• for i in range(len(sequence)-1, -1, -1):
• x = sequence[i]
• <do something with x>
• 
  
• A more elegant solution, is to define a class which acts as a sequence and yields the elements in reverse order (solution due to Steve Majewski):
• 
  
• class Rev:
• def __init__(self, seq):
• self.forw = seq
• def __len__(self):
• return len(self.forw)
• def __getitem__(self, i):
• return self.forw[-(i + 1)]
• 
  
• You can now simply write:
• 
  
• for x in Rev(list):
• <do something with x>
• 
  
• Unfortunately, this solution is slowest of all, due to the method call overhead.
• 
  
• With Python 2.3, you can use an extended slice syntax:
• 
  
• for x in sequence[::-1]:
• <do something with x>
• 
  
• How do you remove duplicates from a list?
  If you don't mind reordering the list, sort it and then scan from the end of the list, deleting duplicates as you go:
• 
  
• if List:
• List.sort()
• last = List[-1]
• for i in range(len(List)-2, -1, -1):
• if last==List[i]: del List[i]
• else: last=List[i]
• 
  
• If all elements of the list may be used as dictionary keys (i.e. they are all hash able) this is often faster
• 
  
• d = {}
• for x in List: d[x]=x
• List = d.values()
• How do you make an array in Python?
• Use a list:
• ["this", 1, "is", "an", "array"]
• 
  
• Lists are equivalent to C or Pascal arrays in their time complexity; the primary difference is that a Python list can contain objects of many different types.
• 
  
• The array module also provides methods for creating arrays of fixed types with compact representations, but they are slower to index than lists. Also note that the Numeric extensions and others define array-like structures with various characteristics as well.
• 
  
• To get Lisp-style linked lists, you can emulate cons cells using tuples:
• 
  
• lisp_list = ("like", ("this", ("example", None) ) )
• 
  
• If mutability is desired, you could use lists instead of tuples. Here the analogue of lisp car is lisp_list[0] and the analogue of cdr is lisp_list[1]. Only do this if you're sure you really need to, because it's usually a lot slower than using Python lists.
• How do I create a multidimensional list?
• You probably tried to make a multidimensional array like this:
• 
  
• A = [[None] * 2] * 3
• 
  
• This looks correct if you print it:
• 
  
• >>> A
• [[None, None], [None, None], [None, None]]
• 
  
• But when you assign a value, it shows up in multiple places:
• 
  
• >>> A[0][0] = 5
• >>> A
• [[5, None], [5, None], [5, None]]
• 
  
• The reason is that replicating a list with * doesn't create copies, it only creates references to the existing objects. The *3 creates a list containing 3 references to the same list of length two. Changes to one row will show in all rows, which is almost certainly not what you want.
• 
  
• The suggested approach is to create a list of the desired length first and then fill in each element with a newly created list:
• 
  
• A = [None]*3
• for i in range(3):
• A[i] = [None] * 2
• 
  
• This generates a list containing 3 different lists of length two. You can also use a list comprehension:
• 
  
• w,h = 2,3
• A = [ [None]*w for i in range(h) ]
• 
  
• Or, you can use an extension that provides a matrix datatype; Numeric Python is the best known.
• How do I apply a method to a sequence of objects?
• Use a list comprehension:
• 
  
• result = [obj.method() for obj in List]
• 
  
• More generically, you can try the following function:
• 
  
• def method_map(objects, method, arguments):
• """method_map([a,b], "meth", (1,2)) gives [a.meth(1,2), b.meth(1,2)]"""
• nobjects = len(objects)
• methods = map(getattr, objects, [method]*nobjects)
• return map(apply, methods, [arguments]*nobjects)
• I want to do a complicated sort: can you do a Schwartzman Transform in Python?
• Yes, it's quite simple with list comprehensions.
• 
  
• The technique, attributed to Randal Schwartz of the Perl community, sorts the elements of a list by a metric which maps each element to its "sort value". To sort a list of strings by their uppercase values:
• 
  
• tmp1 = [ (x.upper(), x) for x in L ] # Schwartzman transform
• tmp1.sort()
• Usorted = [ x[1] for x in tmp1 ]
• 
  
• To sort by the integer value of a subfield extending from positions 10-15 in each string:
• 
  
• tmp2 = [ (int(s[10:15]), s) for s in L ] # Schwartzman transform
• tmp2.sort()
• Isorted = [ x[1] for x in tmp2 ]
• 
  
• Note that Isorted may also be computed by
• 
  
• def intfield(s):
• return int(s[10:15])
• 
  
• def Icmp(s1, s2):
• return cmp(intfield(s1), intfield(s2))
• 
  
• Isorted = L[:]
• Isorted.sort(Icmp)
• 
  
• but since this method calls intfield() many times for each element of L, it is slower than the Schwartzman Transform.
• 
  
• How can I sort one list by values from another list?
  Merge them into a single list of tuples, sort the resulting list, and then pick out the element you want.
• 
  
• >>> list1 = ["what", "I'm", "sorting", "by"]
• >>> list2 = ["something", "else", "to", "sort"]
• >>> pairs = zip(list1, list2)
• >>> pairs
• 
  
• [('what', 'something'), ("I'm", 'else'), ('sorting', 'to'), ('by', 'sort')] >>> pairs.sort()
• >>> result = [ x[1] for x in pairs ]
• >>> result
• ['else', 'sort', 'to', 'something']
• 
  
• An alternative for the last step is:
• 
  
• result = []
• for p in pairs: result.append(p[1])
• 
  
• If you find this more legible, you might prefer to use this instead of the final list comprehension. However, it is almost twice as slow for long lists. Why? First, the append() operation has to reallocate memory, and while it uses some tricks to avoid doing that each time, it still has to do it occasionally, and that costs quite a bit. Second, the expression "result.append" requires an extra attribute lookup, and third, there's a speed reduction from having to make all those function calls.
• What is a class?
• A class is the particular object type created by executing a class statement. Class objects are used as templates to create instance objects, which embody both the data (attributes) and code (methods) specific to a datatype.
• 
  
• A class can be based on one or more other classes, called its base class(es). It then inherits the attributes and methods of its base classes. This allows an object model to be successively refined by inheritance. You might have a generic Mailbox class that provides basic accessor methods for a mailbox, and subclasses such as MboxMailbox, MaildirMailbox, OutlookMailbox that handle various specific mailbox formats.
• What is a method?
• A method is a function on some object x that you normally call as x.name(arguments...). Methods are defined as functions inside the class definition:
• 
  
• class C:
• def meth (self, arg):
• return arg*2 + self.attribute
• What is self?
• Self is merely a conventional name for the first argument of a method. A method defined as meth(self, a, b, c) should be called as x.meth(a, b, c) for some instance x of the class in which the definition occurs; the called method will think it is called as meth(x, a, b, c).
• How do I check if an object is an instance of a given class or of a subclass of it?
• Use the built-in function isinstance(obj, cls). You can check if an object is an instance of any of a number of classes by providing a tuple instead of a single class, e.g. isinstance(obj, (class1, class2, ...)), and can also check whether an object is one of Python's built-in types, e.g. isinstance(obj, str) or isinstance(obj, (int, long, float, complex)).
• 
  
• Note that most programs do not use isinstance() on user-defined classes very often. If you are developing the classes yourself, a more proper object-oriented style is to define methods on the classes that encapsulate a particular behaviour, instead of checking the object's class and doing a different thing based on what class it is. For example, if you have a function that does something:
• 
  
• def search (obj):
• if isinstance(obj, Mailbox):
• # ... code to search a mailbox
• elif isinstance(obj, Document):
• # ... code to search a document
• elif ...
• 
  
• A better approach is to define a search() method on all the classes and just call it:
• 
  
• class Mailbox:
• def search(self):
• # ... code to search a mailbox
• 
  
• class Document:
• def search(self):
• # ... code to search a document
• 
  
• obj.search()
• What is delegation?
• Delegation is an object oriented technique (also called a design pattern). Let's say you have an object x and want to change the behavior of just one of its methods. You can create a new class that provides a new implementation of the method you're interested in changing and delegates all other methods to the corresponding method of x.
• 
  
• Python programmers can easily implement delegation. For example, the following class implements a class that behaves like a file but converts all written data to uppercase:
• 
  
• class UpperOut:
• def __init__(self, outfile):
• self.__outfile = outfile
• def write(self, s):
• self.__outfile.write(s.upper())
• def __getattr__(self, name):
• return getattr(self.__outfile, name)
• 
  
• Here the UpperOut class redefines the write() method to convert the argument string to uppercase before calling the underlying self.__outfile.write() method. All other methods are delegated to the underlying self.__outfile object. The delegation is accomplished via the __getattr__ method; consult the language reference for more information about controlling attribute access.
• 
  
• Note that for more general cases delegation can get trickier. When attributes must be set as well as retrieved, the class must define a __settattr__ method too, and it must do so carefully. The basic implementation of __setattr__ is roughly equivalent to the following:
• 
  
• class X:
• ...
• def __setattr__(self, name, value):
• self.__dict__[name] = value
• ...
• 
  
• Most __setattr__ implementations must modify self.__dict__ to store local state for self without causing an infinite recursion.
• 
  
• How do I call a method defined in a base class from a derived class that overrides it?
  If you're using new-style classes, use the built-in super() function:
• 
  
• class Derived(Base):
• def meth (self):
• super(Derived, self).meth()
• 
  
• If you're using classic classes: For a class definition such as class Derived(Base): ... you can call method meth() defined in Base (or one of Base's base classes) as Base.meth(self, arguments...). Here, Base.meth is an unbound method, so you need to provide the self argument.
• How can I organize my code to make it easier to change the base class?
• You could define an alias for the base class, assign the real base class to it before your class definition, and use the alias throughout your class. Then all you have to change is the value assigned to the alias. Incidentally, this trick is also handy if you want to decide dynamically (e.g. depending on availability of resources) which base class to use. Example:
• 
  
• BaseAlias = <real base class>
• class Derived(BaseAlias):
• def meth(self):
• BaseAlias.meth(self)
• How do I create static class data and static class methods?
• Static data (in the sense of C++ or Java) is easy; static methods (again in the sense of C++ or Java) are not supported directly.
• 
  
• For static data, simply define a class attribute. To assign a new value to the attribute, you have to explicitly use the class name in the assignment:
• 
  
• class C:
• count = 0 # number of times C.__init__ called
• 
  
• def __init__(self):
• C.count = C.count + 1
• 
  
• def getcount(self):
• return C.count # or return self.count
• 
  
• c.count also refers to C.count for any c such that isinstance(c, C) holds, unless overridden by c itself or by some class on the base-class search path from c.__class__ back to C.
• 
  
• Caution: within a method of C, an assignment like self.count = 42 creates a new and unrelated instance vrbl named "count" in self's own dict. Rebinding of a class-static data name must always specify the class whether inside a method or not:
• 
  
• C.count = 314
• 
  
• Static methods are possible when you're using new-style classes:
• 
  
• class C:
• def static(arg1, arg2, arg3):
• # No 'self' parameter!
• ...
• static = staticmethod(static)
• 
  
• However, a far more straightforward way to get the effect of a static method is via a simple module-level function:
• 
  
• def getcount():
• return C.count
• 
  
• If your code is structured so as to define one class (or tightly related class hierarchy) per module, this supplies the desired encapsulation.
• How can I overload constructors (or methods) in Python?
• This answer actually applies to all methods, but the question usually comes up first in the context of constructors.
• 
  
• In C++ you'd write
• 
  
• class C {
• C() { cout << "No arguments\n"; }
• C(int i) { cout << "Argument is " << i << "\n"; }
• }
• 
  
• in Python you have to write a single constructor that catches all cases using default arguments. For example:
• 
  
• class C:
• def __init__(self, i=None):
• if i is None:
• print "No arguments"
• else:
• print "Argument is", i
• 
  
• 
  
• This is not entirely equivalent, but close enough in practice.
• 
  
• You could also try a variable-length argument list, e.g.
• 
  
• def __init__(self, *args):
• ....
• 
  
• The same approach works for all method definitions.
• 
  
• How do I find the current module name?
  A module can find out its own module name by looking at the predefined global variable __name__. If this has the value '__main__', the program is running as a script. Many modules that are usually used by importing them also provide a command-line interface or a self-test, and only execute this code after checking __name__:
• 
  
• def main():
• print 'Running test...'
• ...
• 
  
• if __name__ == '__main__':
• main()
• __import__('x.y.z') returns
• 
  
• Try:
• __import__('x.y.z').y.z
• 
  
• For more realistic situations, you may have to do something like
• m = __import__(s)
• for i in s.split(".")[1:]:
• m = getattr(m, i)
• When I edit an imported module and reimport it, the changes don't show up. Why does this happen?
• For reasons of efficiency as well as consistency, Python only reads the module file on the first time a module is imported. If it didn't, in a program consisting of many modules where each one imports the same basic module, the basic module would be parsed and re-parsed many times. To force rereading of a changed module, do this:
• 
  
• import modname
• reload(modname)
• 
  
• Warning: this technique is not 100% fool-proof. In particular, modules containing statements like
• 
  
• from modname import some_objects
• 
  
• will continue to work with the old version of the imported objects. If the module contains class definitions, existing class instances will not be updated to use the new class definition. This can result in the following paradoxical behavior:
• 
  
• >>> import cls
• >>> c = cls.C() # Create an instance of C
• >>> reload(cls)
• <module 'cls' from 'cls.pyc'>
• >>> isinstance(c, cls.C) # isinstance is false?!?
• False
• 
  
• The nature of the problem is made clear if you print out the class objects:
• 
  
• >>> c.__class__
• <class cls.C at 0x7352a0>
• >>> cls.C
• <class cls.C at 0x4198d0>
• Where is the math.py (socket.py, regex.py, etc.) source file?
• There are (at least) three kinds of modules in Python:
• 
  
• 1. modules written in Python (.py);
• 2. modules written in C and dynamically loaded (.dll, .pyd, .so, .sl, etc);
• 3. modules written in C and linked with the interpreter; to get a list of these, type:
• import sys
• print sys.builtin_module_names
• How do I make a Python script executable on Unix?
• You need to do two things: the script file's mode must be executable and the first line must begin with #! followed by the path of the Python interpreter.
• 
  
• The first is done by executing chmod +x scriptfile or perhaps chmod 755 scriptfile.
• The second can be done in a number of ways. The most straightforward way is to write
• 
  
• #!/usr/local/bin/python
• 
  
• as the very first line of your file, using the pathname for where the Python interpreter is installed on your platform.
• 
  
• If you would like the script to be independent of where the Python interpreter lives, you can use the "env" program. Almost all Unix variants support the following, assuming the python interpreter is in a directory on the user's $PATH:
• 
  
• #! /usr/bin/env python
• 
  
• Don't do this for CGI scripts. The $PATH variable for CGI scripts is often very minimal, so you need to use the actual absolute pathname of the interpreter.
• 
  
• Occasionally, a user's environment is so full that the /usr/bin/env program fails; or there's no env program at all. In that case, you can try the following hack (due to Alex Rezinsky):
• 
  
• #! /bin/sh
• """:"
• exec python $0 ${1+"$@"}
• """
• 
  
• The minor disadvantage is that this defines the script's __doc__ string. However, you can fix that by adding
• 
  
• __doc__ = """...Whatever..."""
• 
  
• Why don't my signal handlers work?
  The most common problem is that the signal handler is declared with the wrong argument list. It is called as
• 
  
• handler(signum, frame)
• 
  
• so it should be declared with two arguments:
• 
  
• def handler(signum, frame):
• ...
• How do I test a Python program or component?
• Python comes with two testing frameworks. The doctest module finds examples in the docstrings for a module and runs them, comparing the output with the expected output given in the docstring.
• 
  
• The unittest module is a fancier testing framework modelled on Java and Smalltalk testing frameworks.
• 
  
• For testing, it helps to write the program so that it may be easily tested by using good modular design. Your program should have almost all functionality encapsulated in either functions or class methods -- and this sometimes has the surprising and delightful effect of making the program run faster (because local variable accesses are faster than global accesses). Furthermore the program should avoid depending on mutating global variables, since this makes testing much more difficult to do.
• 
  
• The "global main logic" of your program may be as simple as
• 
  
• if __name__=="__main__":
• main_logic()
• 
  
• at the bottom of the main module of your program.
• 
  
• Once your program is organized as a tractable collection of functions and class behaviours you should write test functions that exercise the behaviours. A test suite can be associated with each module which automates a sequence of tests. This sounds like a lot of work, but since Python is so terse and flexible it's surprisingly easy. You can make coding much more pleasant and fun by writing your test functions in parallel with the "production code", since this makes it easy to find bugs and even design flaws earlier.
• 
  
• "Support modules" that are not intended to be the main module of a program may include a self-test of the module.
• 
  
• if __name__ == "__main__":
• self_test()
• 
  
• Even programs that interact with complex external interfaces may be tested when the external interfaces are unavailable by using "fake" interfaces implemented in Python.
• None of my threads seem to run: why?
• As soon as the main thread exits, all threads are killed. Your main thread is running too quickly, giving the threads no time to do any work.
• 
  
• A simple fix is to add a sleep to the end of the program that's long enough for all the threads to finish:
• 
  
• import threading, time
• 
  
• def thread_task(name, n):
• for i in range(n): print name, i
• 
  
• for i in range(10):
• T = threading.Thread(target=thread_task, args=(str(i), i))
• T.start()
• 
  
• 
  
• time.sleep(10) # <----------------------------!
• 
  
• But now (on many platforms) the threads don't run in parallel, but appear to run sequentially, one at a time! The reason is that the OS thread scheduler doesn't start a new thread until the previous thread is blocked.
• 
  
• A simple fix is to add a tiny sleep to the start of the run function:
• 
  
• def thread_task(name, n):
• time.sleep(0.001) # <---------------------!
• for i in range(n): print name, i
• 
  
• for i in range(10):
• T = threading.Thread(target=thread_task, args=(str(i), i))
• T.start()
• 
  
• time.sleep(10)
• 
  
• Instead of trying to guess how long a time.sleep() delay will be enough, it's better to use some kind of semaphore mechanism. One idea is to use the Queue module to create a queue object, let each thread append a token to the queue when it finishes, and let the main thread read as many tokens from the queue as there are threads.
• 
  
• How do I parcel out work among a bunch of worker threads?
  Use the Queue module to create a queue containing a list of jobs. The Queue class maintains a list of objects with .put(obj) to add an item to the queue and .get() to return an item. The class will take care of the locking necessary to ensure that each job is handed out exactly once.
• 
  
• Here's a trivial example:
• 
  
• import threading, Queue, time
• 
  
• # The worker thread gets jobs off the queue. When the queue is empty, it
• # assumes there will be no more work and exits.
• # (Realistically workers will run until terminated.)
• def worker ():
• print 'Running worker'
• time.sleep(0.1)
• while True:
• try:
• arg = q.get(block=False)
• except Queue.Empty:
• print 'Worker', threading.currentThread(),
• print 'queue empty'
• break
• else:
• print 'Worker', threading.currentThread(),
• print 'running with argument', arg
• time.sleep(0.5)
• 
  
• # Create queue
• q = Queue.Queue()
• 
  
• # Start a pool of 5 workers
• for i in range(5):
• t = threading.Thread(target=worker, name='worker %i' % (i+1))
• t.start()
• 
  
• # Begin adding work to the queue
• for i in range(50):
• q.put(i)
• 
  
• # Give threads time to run
• print 'Main thread sleeping'
• time.sleep(5)
• 
  
• When run, this will produce the following output:
• 
  
• Running worker Running worker Running worker Running worker Running worker Main thread sleeping Worker <Thread(worker 1, started)> running with argument 0 Worker <Thread(worker 2, started)> running with argument 1 Worker <Thread(worker 3, started)> running with argument 2 Worker <Thread(worker 4, started)> running with argument 3 Worker <Thread(worker 5, started)> running with argument 4 Worker <Thread(worker 1, started)> running with argument 5 ...
• How do I delete a file? (And other file questions...)
• Use os.remove(filename) or os.unlink(filename);
• How do I copy a file?
• The shutil module contains a copyfile() function.
• How do I read (or write) binary data?
• or complex data formats, it's best to use the struct module. It allows you to take a string containing binary data (usually numbers) and convert it to Python objects; and vice versa.
• 
  
• For example, the following code reads two 2-byte integers and one 4-byte integer in big-endian format from a file:
• 
  
• import struct
• 
  
• f = open(filename, "rb") # Open in binary mode for portability
• s = f.read(8)
• x, y, z = struct.unpack(">hhl", s)
• 
  
• 
  
• The '>' in the format string forces big-endian data; the letter 'h' reads one "short integer" (2 bytes), and 'l' reads one "long integer" (4 bytes) from the string.
• How do I run a subprocess with pipes connected to both input and output?
• Use the popen2 module. For example:
• 
  
• import popen2
• fromchild, tochild = popen2.popen2("command")
• tochild.write("input\n")
• tochild.flush()
• output = fromchild.readline()
• How can I mimic CGI form submission (METHOD=POST)?
• I would like to retrieve web pages that are the result of POSTing a form. Is there existing code that would let me do this easily?
• 
  
• Yes. Here's a simple example that uses httplib:
• 
  
• #!/usr/local/bin/python
• 
  
• import httplib, sys, time
• 
  
• ### build the query string
• qs = "First=Josephine&MI=Q&Last=Public"
• 
  
• ### connect and send the server a path
• httpobj = httplib.HTTP('www.some-server.out-there', 80)
• httpobj.putrequest('POST', '/cgi-bin/some-cgi-script')
• ### now generate the rest of the HTTP headers...
• httpobj.putheader('Accept', '*/*')
• httpobj.putheader('Connection', 'Keep-Alive')
• httpobj.putheader('Content-type', 'application/x-www-form-urlencoded')
• httpobj.putheader('Content-length', '%d' % len(qs))
• httpobj.endheaders()
• httpobj.send(qs)
• ### find out what the server said in response...
• reply, msg, hdrs = httpobj.getreply()
• if reply != 200:
• sys.stdout.write(httpobj.getfile().read())
• 
  
• Note that in general for URL-encoded POST operations, query strings must be quoted by using urllib.quote(). For example to send name="Guy Steele, Jr.":
• 
  
• >>> from urllib import quote
• >>> x = quote("Guy Steele, Jr.")
• >>> x
• 'Guy%20Steele,%20Jr.'
• >>> query_string = "name="+x
• >>> query_string
• 'name=Guy%20Steele,%20Jr.'
• 
  
• How do I send mail from a Python script?
  Use the standard library module smtplib.
• 
  
• Here's a very simple interactive mail sender that uses it. This method will work on any host that supports an SMTP listener.
• 
  
• import sys, smtplib
• 
  
• fromaddr = raw_input("From: ")
• toaddrs = raw_input("To: ").split(',')
• print "Enter message, end with ^D:"
• msg = ''
• while 1:
• line = sys.stdin.readline()
• if not line:
• break
• msg = msg + line
• 
  
• # The actual mail send
• server = smtplib.SMTP('localhost')
• server.sendmail(fromaddr, toaddrs, msg)
• server.quit()
• 
  
• A Unix-only alternative uses sendmail. The location of the sendmail program varies between systems; sometimes it is /usr/lib/sendmail, sometime /usr/sbin/sendmail. The sendmail manual page will help you out. Here's some sample code:
• 
  
• SENDMAIL = "/usr/sbin/sendmail" # sendmail location
• import os
• p = os.popen("%s -t -i" % SENDMAIL, "w")
• p.write("To: receiver@example.com\n")
• p.write("Subject: test\n")
• p.write("\n") # blank line separating headers from body
• p.write("Some text\n")
• p.write("some more text\n")
• sts = p.close()
• if sts != 0:
• print "Sendmail exit status", sts
• How do I avoid blocking in the connect() method of a socket?
• The select module is commonly used to help with asynchronous I/O on sockets.
• Are there any interfaces to database packages in Python?
• Yes.
• 
  
• Python 2.3 includes the bsddb package which provides an interface to the BerkeleyDB library. Interfaces to disk-based hashes such as DBM and GDBM are also included with standard Python.
• How do I generate random numbers in Python?
• The standard module random implements a random number generator. Usage is simple:
• 
  
• import random
• random.random()
• 
  
• This returns a random floating point number in the range [0, 1).
• Can I create my own functions in C?
• Yes, you can create built-in modules containing functions, variables, exceptions and even new types in C.
• Can I create my own functions in C++?
• Yes, using the C compatibility features found in C++. Place extern "C" { ... } around the Python include files and put extern "C" before each function that is going to be called by the Python interpreter. Global or static C++ objects with constructors are probably not a good idea.
• How can I execute arbitrary Python statements from C?
• The highest-level function to do this is PyRun_SimpleString() which takes a single string argument to be executed in the context of the module __main__ and returns 0 for success and -1 when an exception occurred (including SyntaxError). If you want more control, use PyRun_String(); see the source for PyRun_SimpleString() in Python/pythonrun.c.
• How can I evaluate an arbitrary Python expression from C?
• Call the function PyRun_String() from the previous question with the start symbol Py_eval_input; it parses an expression, evaluates it and returns its value.
• 
  
• How do I extract C values from a Python object?
  That depends on the object's type. If it's a tuple, PyTupleSize(o) returns its length and PyTuple_GetItem(o, i) returns its i'th item. Lists have similar functions, PyListSize(o) and PyList_GetItem(o, i).
• 
  
• For strings, PyString_Size(o) returns its length and PyString_AsString(o) a pointer to its value. Note that Python strings may contain null bytes so C's strlen() should not be used.
• 
  
• To test the type of an object, first make sure it isn't NULL, and then use PyString_Check(o), PyTuple_Check(o), PyList_Check(o), etc.
• 
  
• There is also a high-level API to Python objects which is provided by the so-called 'abstract' interface -- read Include/abstract.h for further details. It allows interfacing with any kind of Python sequence using calls like PySequence_Length(), PySequence_GetItem(), etc.) as well as many other useful protocols.
• How do I call an object's method from C?
  The PyObject_CallMethod() function can be used to call an arbitrary method of an object. The parameters are the object, the name of the method to call, a format string like that used with Py_BuildValue(), and the argument values:
• 
  
• PyObject *
• PyObject_CallMethod(PyObject *object, char *method_name,
• char *arg_format, ...);
• 
  
• This works for any object that has methods -- whether built-in or user-defined. You are responsible for eventually Py_DECREF'ing the return value.
• 
  
• To call, e.g., a file object's "seek" method with arguments 10, 0 (assuming the file object pointer is "f"):
• 
  
• res = PyObject_CallMethod(f, "seek", "(ii)", 10, 0);
• if (res == NULL) {
• ... an exception occurred ...
• }
• else {
• Py_DECREF(res);
• }
• 
  
• Note that since PyObject_CallObject() always wants a tuple for the argument list, to call a function without arguments, pass "()" for the format, and to call a function with one argument, surround the argument in parentheses, e.g. "(i)".
• How do I catch the output from PyErr_Print() (or anything that prints to stdout/stderr)?
• In Python code, define an object that supports the write() method. Assign this object to sys.stdout and sys.stderr. Call print_error, or just allow the standard traceback mechanism to work. Then, the output will go wherever your write() method sends it.
• 
  
• The easiest way to do this is to use the StringIO class in the standard library.
• 
  
• Sample code and use for catching stdout:
• 
  
• >>> class StdoutCatcher:
• ... def __init__(self):
• ... self.data = ''
• ... def write(self, stuff):
• ... self.data = self.data + stuff
• ...
• >>> import sys
• >>> sys.stdout = StdoutCatcher()
• >>> print 'foo'
• >>> print 'hello world!'
• >>> sys.stderr.write(sys.stdout.data)
• foo
• hello world!
• How do I access a module written in Python from C?
• You can get a pointer to the module object as follows:
• 
  
• module = PyImport_ImportModule("<modulename>");
• 
  
• If the module hasn't been imported yet (i.e. it is not yet present in sys.modules), this initializes the module; otherwise it simply returns the value of sys.modules["<modulename>"]. Note that it doesn't enter the module into any namespace -- it only ensures it has been initialized and is stored in sys.modules.
• 
  
• You can then access the module's attributes (i.e. any name defined in the module) as follows:
• 
  
• attr = PyObject_GetAttrString(module, "<attrname>");
• 
  
• Calling PyObject_SetAttrString() to assign to variables in the module also works.
• How do I interface to C++ objects from Python?
• Depending on your requirements, there are many approaches. To do this manually, begin by reading the "Extending and Embedding" document. Realize that for the Python run-time system, there isn't a whole lot of difference between C and C++ -- so the strategy of building a new Python type around a C structure (pointer) type will also work for C++ objects.
• 
  
• How do I tell "incomplete input" from "invalid input"?
  Sometimes you want to emulate the Python interactive interpreter's behavior, where it gives you a continuation prompt when the input is incomplete (e.g. you typed the start of an "if" statement or you didn't close your parentheses or triple string quotes), but it gives you a syntax error message immediately when the input is invalid.
• 
  
• In Python you can use the codeop module, which approximates the parser's behavior sufficiently. IDLE uses this, for example.
• 
  
• The easiest way to do it in C is to call PyRun_InteractiveLoop() (perhaps in a separate thread) and let the Python interpreter handle the input for you. You can also set the PyOS_ReadlineFunctionPointer to point at your custom input function. See Modules/readline.c and Parser/myreadline.c for more hints.
• 
  
• However sometimes you have to run the embedded Python interpreter in the same thread as your rest application and you can't allow the PyRun_InteractiveLoop() to stop while waiting for user input. The one solution then is to call PyParser_ParseString() and test for e.error equal to E_EOF, which means the input is incomplete). Here's a sample code fragment, untested, inspired by code from Alex Farber:
• #include <Python.h>
• #include <node.h>
• #include <errcode.h>
• #include <grammar.h>
• #include <parsetok.h>
• #include <compile.h>
• 
  
• int testcomplete(char *code)
• /* code should end in \n */
• /* return -1 for error, 0 for incomplete,
• 1 for complete */
• {
• node *n;
• perrdetail e;
• 
  
• n = PyParser_ParseString(code, &_PyParser_Grammar,
• Py_file_input, &e);
• if (n == NULL) {
• if (e.error == E_EOF)
• return 0;
• return -1;
• }
• 
  
• PyNode_Free(n);
• return 1;
• }
• 
  
• 
  
• Another solution is trying to compile the received string with Py_CompileString(). If it compiles without errors, try to execute the returned code object by calling PyEval_EvalCode(). Otherwise save the input for later. If the compilation fails, find out if it's an error or just more input is required - by extracting the message string from the exception tuple and comparing it to the string "unexpected EOF while parsing". Here is a complete example using the GNU readline library (you may want to ignore SIGINT while calling readline()):
• #include <stdio.h>
• #include <readline.h>
• 
  
• #include <Python.h>
• #include <object.h>
• #include <compile.h>
• #include <eval.h>
• 
  
• int main (int argc, char* argv[])
• {
• int i, j, done = 0; /* lengths of line, code */
• char ps1[] = ">>> ";
• char ps2[] = "... ";
• char *prompt = ps1;
• char *msg, *line, *code = NULL;
• PyObject *src, *glb, *loc;
• PyObject *exc, *val, *trb, *obj, *dum;
• 
  
• Py_Initialize ();
• loc = PyDict_New ();
• glb = PyDict_New ();
• PyDict_SetItemString (glb, "__builtins__",
• PyEval_GetBuiltins ());
• 
  
• while (!done)
• {
• line = readline (prompt);
• 
  
• if (NULL == line) /* CTRL-D pressed */
• {
• done = 1;
• }
• else
• {
• i = strlen (line);
• 
  
• if (i > 0)
• add_history (line);
• /* save non-empty lines */
• 
  
• if (NULL == code)
• /* nothing in code yet */
• j = 0;
• else
• j = strlen (code);
• 
  
• code = realloc (code, i + j + 2);
• if (NULL == code)
• /* out of memory */
• exit (1);
• 
  
• if (0 == j)
• /* code was empty, so */
• code[0] = '\0';
• /* keep strncat happy */
• 
  
• strncat (code, line, i);
• /* append line to code */
• code[i + j] = '\n';
• /* append '\n' to code */
• code[i + j + 1] = '\0';
• 
  
• src = Py_CompileString (code, " <stdin>", Py_single_input);
• 
  
• if (NULL != src)
• /* compiled just fine - */
• {
• if (ps1 == prompt ||
• /* ">>> " or */
• '\n' == code[i + j - 1])
• /* "... " and double '\n' */
• {
• /* so execute it */
• dum = PyEval_EvalCode ((PyCodeObject *)src, glb, loc);
• Py_XDECREF (dum);
• Py_XDECREF (src);
• free (code);
• code = NULL;
• if (PyErr_Occurred ())
• PyErr_Print ();
• prompt = ps1;
• }
• }
• /* syntax error or E_EOF? */
• 
  
• else if (PyErr_ExceptionMatches (PyExc_SyntaxError))
• {
• PyErr_Fetch (&exc, &val, &trb);
• /* clears exception! */
• 
  
• if (PyArg_ParseTuple (val, "sO", &msg, &obj) &&
• !strcmp (msg, "unexpected EOF while parsing")) /* E_EOF */
• {
• Py_XDECREF (exc);
• Py_XDECREF (val);
• Py_XDECREF (trb);
• prompt = ps2;
• }
• else
• /* some other syntax error */
• {
• PyErr_Restore (exc, val, trb);
• PyErr_Print ();
• free (code);
• code = NULL;
• prompt = ps1;
• }
• }
• else
• /* some non-syntax error */
• {
• PyErr_Print ();
• free (code);
• code = NULL;
• prompt = ps1;
• }
• 
  
• free (line);
• }
• }
• 
  
• Py_XDECREF(glb);
• Py_XDECREF(loc);
• Py_Finalize();
• exit(0);
• }
• 
  
• How do I run a Python program under Windows?
  This is not necessarily a straightforward question. If you are already familiar with running programs from the Windows command line then everything will seem obvious; otherwise, you might need a little more guidance. There are also differences between Windows 95, 98, NT, ME, 2000 and XP which can add to the confusion.
• 
  
• Unless you use some sort of integrated development environment, you will end up typing Windows commands into what is variously referred to as a "DOS window" or "Command prompt window". Usually you can create such a window from your Start menu; under Windows 2000 the menu selection is "Start | Programs | Accessories | Command Prompt". You should be able to recognize when you have started such a window because you will see a Windows "command prompt", which usually looks like this:
• 
  
• C:\>
• 
  
• The letter may be different, and there might be other things after it, so you might just as easily see something like:
• 
  
• D:\Steve\Projects\Python>
• 
  
• depending on how your computer has been set up and what else you have recently done with it. Once you have started such a window, you are well on the way to running Python programs.
• 
  
• You need to realize that your Python scripts have to be processed by another program called the Python interpreter. The interpreter reads your script, compiles it into bytecodes, and then executes the bytecodes to run your program. So, how do you arrange for the interpreter to handle your Python?
• 
  
• First, you need to make sure that your command window recognises the word "python" as an instruction to start the interpreter. If you have opened a command window, you should try entering the command python and hitting return. You should then see something like:
• 
  
• Python 2.2 (#28, Dec 21 2001, 12:21:22) [MSC 32 bit (Intel)] on win32
• Type "help", "copyright", "credits" or "license" for more information.
• >>>
• 
  
• 
  
• You have started the interpreter in "interactive mode". That means you can enter Python statements or expressions interactively and have them executed or evaluated while you wait. This is one of Python's strongest features. Check it by entering a few expressions of your choice and seeing the results:
• 
  
• >>> print "Hello"
• Hello
• >>> "Hello" * 3
• HelloHelloHello
• 
  
• Many people use the interactive mode as a convenient yet highly programmable calculator. When you want to end your interactive Python session, hold the Ctrl key down while you enter a Z, then hit the "Enter" key to get back to your Windows command prompt.
• 
  
• You may also find that you have a Start-menu entry such as "Start | Programs | Python 2.2 | Python (command line)" that results in you seeing the >>> prompt in a new window. If so, the window will disappear after you enter the Ctrl-Z character; Windows is running a single "python" command in the window, and closes it when you terminate the interpreter.
• 
  
• If the python command, instead of displaying the interpreter prompt >>>, gives you a message like:
• 
  
• 'python' is not recognized as an internal or external command,
• operable program or batch file.
• 
  
• or:
• 
  
• Bad command or filename
• 
  
• then you need to make sure that your computer knows where to find the Python interpreter. To do this you will have to modify a setting called PATH, which is a list of directories where Windows will look for programs. You should arrange for Python's installation directory to be added to the PATH of every command window as it starts. If you installed Python fairly recently then the command
• 
  
• dir C:\py*
• 
  
• will probably tell you where it is installed; the usual location is something like C:\Python23. Otherwise you will be reduced to a search of your whole disk ... use "Tools | Find" or hit the "Search" button and look for "python.exe". Supposing you discover that Python is installed in the C:\Python23 directory (the default at the time of writing), you should make sure that entering the command
• 
  
• c:\Python23\python
• 
  
• starts up the interpreter as above (and don't forget you'll need a "CTRL-Z" and an "Enter" to get out of it). Once you have verified the directory, you need to add it to the start-up routines your computer goes through. For older versions of Windows the easiest way to do this is to edit the C:\AUTOEXEC.BAT file. You would want to add a line like the following to AUTOEXEC.BAT:
• 
  
• PATH C:\Python23;%PATH%
• 
  
• For Windows NT, 2000 and (I assume) XP, you will need to add a string such as
• 
  
• ;C:\Python23
• 
  
• to the current setting for the PATH environment variable, which you will find in the properties window of "My Computer" under the "Advanced" tab. Note that if you have sufficient privilege you might get a choice of installing the settings either for the Current User or for System. The latter is preferred if you want everybody to be able to run Python on the machine.
• 
  
• If you aren't confident doing any of these manipulations yourself, ask for help! At this stage you may want to reboot your system to make absolutely sure the new setting has taken effect. You probably won't need to reboot for Windows NT, XP or 2000. You can also avoid it in earlier versions by editing the file C:\WINDOWS\COMMAND\CMDINIT.BAT instead of AUTOEXEC.BAT.
• 
  
• You should now be able to start a new command window, enter python at the C:> (or whatever) prompt, and see the >>> prompt that indicates the Python interpreter is reading interactive commands.
• 
  
• Let's suppose you have a program called pytest.py in directory C:\Steve\Projects\Python. A session to run that program might look like this:
• 
  
• C:\> cd \Steve\Projects\Python
• C:\Steve\Projects\Python> python pytest.py
• 
  
• Because you added a file name to the command to start the interpreter, when it starts up it reads the Python script in the named file, compiles it, executes it, and terminates, so you see another C:\> prompt. You might also have entered
• 
  
• C:\> python \Steve\Projects\Python\pytest.py
• 
  
• if you hadn't wanted to change your current directory.
• 
  
• Under NT, 2000 and XP you may well find that the installation process has also arranged that the command pytest.py (or, if the file isn't in the current directory, C:\Steve\Projects\Python\pytest.py) will automatically recognize the ".py" extension and run the Python interpreter on the named file. Using this feature is fine, but some versions of Windows have bugs which mean that this form isn't exactly equivalent to using the interpreter explicitly, so be careful.
• 
  
• The important things to remember are:
• 1. Start Python from the Start Menu, or make sure the PATH is set correctly so Windows can find the Python interpreter.
• 
  
• python
• 
  
• should give you a '>>>" prompt from the Python interpreter. Don't forget the CTRL-Z and ENTER to terminate the interpreter (and, if you started the window from the Start Menu, make the window disappear).
• 
  
• 2. Once this works, you run programs with commands:
• 
  
• python {program-file}
• 
  
• 3. When you know the commands to use you can build Windows shortcuts to run the Python interpreter on any of your scripts, naming particular working directories, and adding them to your menus. Take a look at
• 
  
• python --help
• 
  
• if your needs are complex.
• 4. Interactive mode (where you see the >>> prompt) is best used for checking that individual statements and expressions do what you think they will, and for developing code by experiment.
• 
  
• How do I make python scripts executable?
  On Windows 2000, the standard Python installer already associates the .py extension with a file type (Python.File) and gives that file type an open command that runs the interpreter (D:\Program Files\Python\python.exe "%1" %*). This is enough to make scripts executable from the command prompt as 'foo.py'. If you'd rather be able to execute the script by simple typing 'foo' with no extension you need to add .py to the PATHEXT environment variable.
• 
  
• On Windows NT, the steps taken by the installer as described above allow you to run a script with 'foo.py', but a longtime bug in the NT command processor prevents you from redirecting the input or output of any script executed in this way. This is often important.
• 
  
• The incantation for making a Python script executable under WinNT is to give the file an extension of .cmd and add the following as the first line:
• 
  
• @setlocal enableextensions & python -x %~f0 %* & goto :EOF
• How do I debug an extension?
• When using GDB with dynamically loaded extensions, you can't set a breakpoint in your extension until your extension is loaded.
• 
  
• In your .gdbinit file (or interactively), add the command:
• 
  
• br _PyImport_LoadDynamicModule
• 
  
• Then, when you run GDB:
• 
  
• $ gdb /local/bin/python
• gdb) run myscript.py
• gdb) continue # repeat until your extension is loaded
• gdb) finish # so that your extension is loaded
• gdb) br myfunction.c:50
• gdb) continue
• Where is Freeze for Windows?
  "Freeze" is a program that allows you to ship a Python program as a single stand-alone executable file. It is not a compiler; your programs don't run any faster, but they are more easily distributable, at least to platforms with the same OS and CPU.
• Is a *.pyd file the same as a DLL?
• Yes, .
• How can I embed Python into a Windows application?
• Embedding the Python interpreter in a Windows app can be summarized as follows:
• 
  
• 1. Do _not_ build Python into your .exe file directly. On Windows, Python must be a DLL to handle importing modules that are themselves DLL's. (This is the first key undocumented fact.) Instead, link to pythonNN.dll; it is typically installed in C:\Windows\System. NN is the Python version, a number such as "23" for Python 2.3.
• 
  
• You can link to Python statically or dynamically. Linking statically means linking against pythonNN.lib, while dynamically linking means linking against pythonNN.dll. The drawback to dynamic linking is that your app won't run if pythonNN.dll does not exist on your system. (General note: pythonNN.lib is the so-called "import lib" corresponding to python.dll. It merely defines symbols for the linker.)
• 
  
• Linking dynamically greatly simplifies link options; everything happens at run time. Your code must load pythonNN.dll using the Windows LoadLibraryEx() routine. The code must also use access routines and data in pythonNN.dll (that is, Python's C API's) using pointers obtained by the Windows GetProcAddress() routine. Macros can make using these pointers transparent to any C code that calls routines in Python's C API.
• 
  
• Borland note: convert pythonNN.lib to OMF format using Coff2Omf.exe first.
• 
  
• 2. If you use SWIG, it is easy to create a Python "extension module" that will make the app's data and methods available to Python. SWIG will handle just about all the grungy details for you. The result is C code that you link into your .exe file (!) You do _not_ have to create a DLL file, and this also simplifies linking.
• 
  
• 3. SWIG will create an init function (a C function) whose name depends on the name of the extension module. For example, if the name of the module is leo, the init function will be called initleo(). If you use SWIG shadow classes, as you should, the init function will be called initleoc(). This initializes a mostly hidden helper class used by the shadow class.
• 
  
• The reason you can link the C code in step 2 into your .exe file is that calling the initialization function is equivalent to importing the module into Python! (This is the second key undocumented fact.)
• 
  
• 4. In short, you can use the following code to initialize the Python interpreter with your extension module.
• 
  
• #include "python.h"
• ...
• Py_Initialize(); // Initialize Python.
• initmyAppc(); // Initialize (import) the helper class.
• PyRun_SimpleString("import myApp") ; // Import the shadow class.
• 
  
• 5. There are two problems with Python's C API which will become apparent if you use a compiler other than MSVC, the compiler used to build pythonNN.dll.
• 
  
• Problem 1: The so-called "Very High Level" functions that take FILE * arguments will not work in a multi-compiler environment because each compiler's notion of a struct FILE will be different. From an implementation standpoint these are very _low_ level functions.
• 
  
• Problem 2: SWIG generates the following code when generating wrappers to void functions:
• 
  
• Py_INCREF(Py_None);
• _resultobj = Py_None;
• return _resultobj;
• 
  
• Alas, Py_None is a macro that expands to a reference to a complex data structure called _Py_NoneStruct inside pythonNN.dll. Again, this code will fail in a mult-compiler environment. Replace such code by:
• 
  
• return Py_BuildValue("");
• 
  
• It may be possible to use SWIG's %typemap command to make the change automatically, though I have not been able to get this to work (I'm a complete SWIG newbie).
• 
  
• 6. Using a Python shell script to put up a Python interpreter window from inside your Windows app is not a good idea; the resulting window will be independent of your app's windowing system. Rather, you (or the wxPythonWindow class) should create a "native" interpreter window. It is easy to connect that window to the Python interpreter. You can redirect Python's i/o to _any_ object that supports read and write, so all you need is a Python object (defined in your extension module) that contains read() and write() methods.
• 
  
• How do I use Python for CGI?
  On the Microsoft IIS server or on the Win95 MS Personal Web Server you set up Python in the same way that you would set up any other scripting engine.
• 
  
• Run regedt32 and go to:
• 
  
• HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC\Parameters\ScriptMap
• 
  
• and enter the following line (making any specific changes that your system may need):
• 
  
• .py :REG_SZ: c:\\python.exe -u %s %s
• 
  
• This line will allow you to call your script with a simple reference like: http://yourserver/scripts/yourscript.py provided "scripts" is an "executable" directory for your server (which it usually is by default). The "-u" flag specifies unbuffered and binary mode for stdin - needed when working with binary data.
• 
  
• In addition, it is recommended that using ".py" may not be a good idea for the file extensions when used in this context (you might want to reserve *.py for support modules and use *.cgi or *.cgp for "main program" scripts).
• 
  
• In order to set up Internet Information Services 5 to use Python for CGI processing, please see the following links:
• 
  
• http://www.e-coli.net/pyiis_server.html (for Win2k Server) http://www.e-coli.net/pyiis.html (for Win2k pro)
• 
  
• Configuring Apache is much simpler. In the Apache configuration file httpd.conf, add the following line at the end of the file:
• 
  
• ScriptInterpreterSource Registry
• 
  
• Then, give your Python CGI-scripts the extension .py and put them in the cgi-bin directory.
• How do I emulate os.kill() in Windows?
• Use win32api:
• 
  
• def kill(pid):
• """kill function for Win32"""
• import win32api
• handle = win32api.OpenProcess(1, 0, pid)
• return (0 != win32api.TerminateProcess(handle, 0))
• Why does os.path.isdir() fail on NT shared directories?
• The solution appears to be always append the "\" on the end of shared drives.
• 
  
• >>> import os
• >>>os.path.isdir( '\\\\rorschach\\public')
• 0
• >>>os.path.isdir( '\\\\rorschach\\public\\')
• 1
• 
  
• It helps to think of share points as being like drive letters. Example:
• 
  
• k: is not a directory
• k:\ is a directory
• k:\media is a directory
• k:\media\ is not a directory
• 
  
• The same rules apply if you substitute "k:" with "\conkyfoo":
• 
  
• \\conky\foo is not a directory
• \\conky\foo\ is a directory
• \\conky\foo\media is a directory
• \\conky\foo\media\ is not a directory
• Web Python
• Some host providers only let you run CGI scripts in a certain directory, often named cgi-bin. In this case all you have to do to run the script is to call it like this:
• 
  
• http://my_server.tld/cgi-bin/my_script.py
• 
  
• The script will have to be made executable by "others". Give it a 755 permission or check the executable boxes if there is a graphical FTP interface.
• 
  
• Some hosts let you run CGI scripts in any directory. In some of these hosts you don't have to do anything do configure the directories. In others you will have to add these lines to a file named .htaccess in the directory you want to run CGI scripts from:
• 
  
• Options +ExecCGI
• AddHandler cgi-script .py
• 
  
• If the file does not exist create it. All directories below a directory with a .htaccess file will inherit the configurations. So if you want to be able to run CGI scripts from all directories create this file in the document root.
• 
  
• To run a script saved at the root:
• 
  
• http://my_server.tld/my_script.py
• 
  
• If it was saved in some directory:
• 
  
• http://my_server.tld/some_dir/some_subdir/my_script.py
• 
  
• Make sure all text files you upload to the server are uploaded as text (not binary), specially if you are in Windows, otherwise you will have problems.
• 
  
• The classical "Hello World" in python CGI fashion:
  #!/usr/bin/env python
• print "Content-Type: text/html"
• print
• print """\
• <html>
• <body>
• <h2>Hello World!
• </body>
• </html>
• """
• 
  
• To test your setup save it with the .py extension, upload it to your server as text and make it executable before trying to run it.
• 
  
• The first line of a python CGI script sets the path where the python interpreter will be found in the server. Ask your provider what is the correct one. If it is wrong the script will fail. Some examples:
• 
  
• #!/usr/bin/python
• #!/usr/bin/python2.3
• #!/usr/bin/python2.4
• 
  
• It is necessary that the script outputs the HTTP header. The HTTP header consists of one or more messages followed by a blank line. If the output of the script is to be interpreted as HTML then the content type will be text/html. The blank line signals the end of the header and is required.
• 
  
• print "Content-Type: text/html"
• print
• 
  
• If you change the content type to text/plain the browser will not interpret the script's output as HTML but as pure text and you will only see the HTML source. Try it now to never forget. A page refresh may be necessary for it to work.
• 
  
• Client versus Server
• 
  
• All python code will be executed at the server only. The client's agent (for example the browser) will never see a single line of python. Instead it will only get the script's output. This is something realy important to understand.
• 
  
• When programming for the Web you are in a client-server environment, that is, do not make things like trying to open a file in the client's computer as if the script were running there. It isn't.
• How to Debugging in python?
• Syntax and header errors are hard to catch unless you have access to the server logs. Syntax error messages can be seen if the script is run in a local shell before uploading to the server.
• 
  
• For a nice exceptions report there is the cgitb module. It will show a traceback inside a context. The default output is sent to standard output as HTML:
• 
  
• #!/usr/bin/env python
• print "Content-Type: text/html"
• print
• import cgitb; cgitb.enable()
• print 1/0
• 
  
• The handler() method can be used to handle only the catched exceptions:
• 
  
• #!/usr/bin/env python
• print "Content-Type: text/html"
• print
• import cgitb
• try:
• f = open('non-existent-file.txt', 'r')
• except:
• cgitb.handler()
• 
  
• There is also the option for a crude approach making the header "text/plain" and setting the standard error to standard out:
• 
  
• #!/usr/bin/env python
• print "Content-Type: text/plain"
• print
• import sys
• sys.stderr = sys.stdout
• f = open('non-existent-file.txt', 'r')
• 
  
• Will output this:
• 
  
• Traceback (most recent call last):
• File "/var/www/html/teste/cgi-bin/text_error.py", line 6, in ?
• f = open('non-existent-file.txt', 'r')
• IOError: [Errno 2] No such file or directory: 'non-existent-file.txt'
• 
  
• Warning: These techniques expose information that can be used by an attacker. Use it only while developing/debugging. Once in production disable it.
• 
  
• How to make Forms in python?
  The FieldStorage class of the cgi module has all that is needed to handle submited forms.
• 
  
• import cgi
• form = cgi.FieldStorage() # instantiate only once!
• 
  
• It is transparent to the programmer if the data was submited by GET or by POST. The interface is exactly the same.
• 
  
• * Unique field names :
• 
  
• Suppose we have this HTML form which submits a field named name to a python CGI script named process_form.py:
• 
  
• <html><body>
• <form method="get" action="process_form.py">
• Name: <input type="text" name="name">
• <input type="submit" value="Submit">
• </form>
• </body></html>
• 
  
• This is the process_form.py script:
• 
  
• #!/usr/bin/env python
• import cgi
• form = cgi.FieldStorage() # instantiate only once!
• name = form.getfirst('name', 'empty')
• 
  
• # Avoid script injection escaping the user input
• name = cgi.escape(name)
• 
  
• print """\
• Content-Type: text/html\n
• <html><body>
• <p>The submited name was "%s"</p>
• </body></html>
• """ % name
• 
  
• The getfirst() method returns the first value of the named field or a default or None if no field with that name was submited or if it is empty. If there is more than one field with the same name only the first will be returned.
• 
  
• If you change the HTML form method from get to post the process_form.py script will be the same.
• 
  
• * Multiple field names:
• 
  
• If there is more than one field with the same name like in HTML input check boxes then the method to be used is getlist(). It will return a list containing as many items (the values) as checked boxes. If no check box was checked the list will be empty.
• 
  
• Sample HTML with check boxes:
• 
  
• <html><body>
• <form method="post" action="process_check.py">
• Red<input type="checkbox" name="color" value="red">
• Green<input type="checkbox" name="color" value="green">
• <input type="submit" value="Submit">
• </form>
• </body></html>
• 
  
• And the corresponding process_check.py script:
• 
  
• #!/usr/bin/env python
• import cgi
• form = cgi.FieldStorage()
• 
  
• # getlist() returns a list containing the
• # values of the fields with the given name
• colors = form.getlist('color')
• 
  
• print "Content-Type: text/html\n"
• print '<html><body>'
• print 'The colors list:', colors
• for color in colors:
• print '<p>', cgi.escape(color), '</p>'
• print '</body></html>'
• 
  
• * File Upload;
• 
  
• To upload a file the HTML form must have the enctype attribute set to multipart/form-data. The input tag with the file type will create a "Browse" button.
• 
  
• <html><body>
• <form enctype="multipart/form-data" action="save_file.py" method="post">
• <p>File: <input type="file" name="file"></p>
• <p><input type="submit" value="Upload"></p>
• </form>
• </body></html>
• 
  
• The getfirst() and getlist() methods will only return the file(s) content. To also get the filename it is necessary to access a nested FieldStorage instance by its index in the top FieldStorage instance.
• 
  
• #!/usr/bin/env python
• import cgi
• form = cgi.FieldStorage()
• 
  
• # A nested FieldStorage instance holds the file
• fileitem = form['file']
• 
  
• # Test if the file was uploaded
• if fileitem.filename:
• open('files/' + fileitem.filename, 'w').write(fileitem.file.read())
• message = 'The file "' + fileitem.filename + '" was uploaded successfully'
• else:
• message = 'No file was uploaded'
• 
  
• print """\
• Content-Type: text/html\n
• <html><body>
• <p>%s</p>
• </body></html>
• """ % (message,)
• 
  
• The Apache user must have write permission on the directory where the file will be saved.
• 
  
• * Big File Upload
• 
  
• To handle big files without using all the available memory a generator can be used. The generator will return the file in small chunks:
• 
  
• #!/usr/bin/env python
• import cgi
• form = cgi.FieldStorage()
• 
  
• # Generator to buffer file chunks
• def fbuffer(f, chunk_size=10000):
• while True:
• chunk = f.read(chunk_size)
• if not chunk: break
• yield chunk
• 
  
• # A nested FieldStorage instance holds the file
• fileitem = form['file']
• 
  
• # Test if the file was uploaded
• if fileitem.filename:
• f = open('files/' + fileitem.filename, 'w')
• 
  
• # Read the file in chunks
• for chunk in fbuffer(fileitem.file):
• f.write(chunk)
• f.close()
• message = 'The file "' + fileitem.filename + '" was uploaded successfully'
• else:
• message = 'No file was uploaded'
• 
  
• print """\
• Content-Type: text/html\n
• <html><body>
• <p>%s</p>
• </body></html>
• """ % (message,)
• How to use Cookies for Web python ?
  HTTP is said to be a stateless protocol. What this means for web programmers is that every time a user loads a page it is the first time for the server. The server can't say whether this user has ever visited that site, if is he in the middle of a buying transaction, if he has already authenticated, etc.
• 
  
• A cookie is a tag that can be placed on the user's computer. Whenever the user loads a page from a site the site's script can send him a cookie. The cookie can contain anything the site needs to identify that user. Then within the next request the user does for a new page there goes back the cookie with all the pertinent information to be read by the script.
• 
  
• * Set the Cookie;
• 
  
• There are two basic cookie operations. The first is to set the cookie as an HTTP header to be sent to the client. The second is to read the cookie returned from the client also as an HTTP header.
• 
  
• This script will do the first one placing a cookie on the client's browser:
• 
  
• #!/usr/bin/env python
• import time
• 
  
• # This is the message that contains the cookie
• # and will be sent in the HTTP header to the client
• print 'Set-Cookie: lastvisit=' + str(time.time());
• 
  
• # To save one line of code
• # we replaced the print command with a '\n'
• print 'Content-Type: text/html\n'
• # End of HTTP header
• 
  
• print '<html><body>'
• print 'Server time is', time.asctime(time.localtime())
• print '</body></html>'
• 
  
• The Set-Cookie header contains the cookie. Save and run this code from your browser and take a look at the cookie saved there. Search for the cookie name, lastvisit, or for the domain name, or the server IP like 10.1.1.1 or 127.0.0.1.
• 
  
• The Cookie Object
• 
  
• The Cookie module can save us a lot of coding and errors and the next pages will use it in all cookie operations.
• 
  
• #!/usr/bin/env python
• import time, Cookie
• 
  
• # Instantiate a SimpleCookie object
• cookie = Cookie.SimpleCookie()
• 
  
• # The SimpleCookie instance is a mapping
• cookie['lastvisit'] = str(time.time())
• 
  
• # Output the HTTP message containing the cookie
• print cookie
• print 'Content-Type: text/html\n'
• 
  
• print '<html><body>'
• print 'Server time is', time.asctime(time.localtime())
• print '</body></html>'
• 
  
• It does not seem as much for this extremely simple code, but wait until it gets complex and the Cookie module will be your friend.
• 
  
• * Retrieve the Cookie;
• 
  
• The returned cookie will be available as a string in the os.environ dictionary with the key 'HTTP_COOKIE':
• 
  
• cookie_string = os.environ.get('HTTP_COOKIE')
• 
  
• The load() method of the SimpleCookie object will parse that string rebuilding the object's mapping:
• 
  
• cookie.load(cookie_string)
• 
  
• Complete code:
• 
  
• #!/usr/bin/env python
• import Cookie, os, time
• 
  
• cookie = Cookie.SimpleCookie()
• cookie['lastvisit'] = str(time.time())
• 
  
• print cookie
• print 'Content-Type: text/html\n'
• 
  
• print '<html><body>'
• print '<p>Server time is', time.asctime(time.localtime()), '</p>'
• 
  
• # The returned cookie is available in the os.environ dictionary
• cookie_string = os.environ.get('HTTP_COOKIE')
• 
  
• # The first time the page is run there will be no cookies
• if not cookie_string:
• print '<p>First visit or cookies disabled</p>'
• 
  
• else: # Run the page twice to retrieve the cookie
• print '<p>The returned cookie string was "' + cookie_string + '"</p>'
• 
  
• # load() parses the cookie string
• cookie.load(cookie_string)
• # Use the value attribute of the cookie to get it
• lastvisit = float(cookie['lastvisit'].value)
• 
  
• print '<p>Your last visit was at',
• print time.asctime(time.localtime(lastvisit)), '</p>'
• 
  
• print '</body></html>'
• 
  
• When the client first loads the page there will be no cookie in the client's computer to be returned. The second time the page is requested then the cookie saved in the last run will be sent to the server.
• 
  
• * Morsels
• 
  
• In the previous cookie retrieve program the lastvisit cookie value was retrieved through its value attribute:
• 
  
• lastvisit = float(cookie['lastvisit'].value)
• 
  
• When a new key is set for a SimpleCookie object a Morsel instance is created:
• 
  
• >>> import Cookie
• >>> import time
• >>>
• >>> cookie = Cookie.SimpleCookie()
• >>> cookie
• <SimpleCookie: >
• >>>
• >>> cookie['lastvisit'] = str(time.time())
• >>> cookie['lastvisit']
• <Morsel: lastvisit='1159535133.33'>
• >>>
• >>> cookie['lastvisit'].value
• '1159535133.33'
• 
  
• Each cookie, a Morsel instance, can only have a predefined set of keys: expires, path, commnent, domain, max-age, secure and version. Any other key will raise an exception.
• 
  
• #!/usr/bin/env python
• import Cookie, time
• 
  
• cookie = Cookie.SimpleCookie()
• 
  
• # name/value pair
• cookie['lastvisit'] = str(time.time())
• 
  
• # expires in x seconds after the cookie is output.
• # the default is to expire when the browser is closed
• cookie['lastvisit']['expires'] = 30 * 24 * 60 * 60
• 
  
• 
  
• # path in which the cookie is valid.
• # if set to '/' it will valid in the whole domain.
• # the default is the script's path.
• cookie['lastvisit']['path'] = '/cgi-bin'
• 
  
• # the purpose of the cookie to be inspected by the user
• cookie['lastvisit']['comment'] = 'holds the last user\'s visit date'
• 
  
• # domain in which the cookie is valid. always stars with a dot.
• # to make it available in all subdomains
• # specify only the domain like .my_site.com
• cookie['lastvisit']['domain'] = '.www.my_site.com'
• 
  
• # discard in x seconds after the cookie is output
• # not supported in most browsers
• cookie['lastvisit']['max-age'] = 30 * 24 * 60 * 60
• 
  
• # secure has no value. If set directs the user agent to use
• # only (unspecified) secure means to contact the origin
• # server whenever it sends back this cookie
• cookie['lastvisit']['secure'] = ''
• 
  
• # a decimal integer, identifies to which version of
• # the state management specification the cookie conforms.
• cookie['lastvisit']['version'] = 1
• 
  
• print 'Content-Type: text/html\n'
• 
  
• print '<p>', cookie, '</p>'
• for morsel in cookie:
• print '<p>', morsel, '=', cookie[morsel].value
• print '<div style="margin:-1em auto auto 3em;">'
• for key in cookie[morsel]:
• print key, '=', cookie[morsel][key], '<br />'
• print '</div>
• '
• 
  
• Notice that print cookie automatically formats the expire date.
• 
  
• 
  
• How to use Sessions for Web python ?
  Sessions are the server side version of cookies. While a cookie persists data (or state) at the client, sessions do it at the server. Sessions have the advantage that the data do not travel the network thus making it both safer and faster although this not entirely true as shown in the next paragraph
• 
  
• The session state is kept in a file or in a database at the server side. Each session is identified by an id or session id (SID). To make it possible to the client to identify himself to the server the SID must be created by the server and sent to the client and then sent back to the server whenever the client makes a request. There is still data going through the net, the SID.
• 
  
• The server can send the SID to the client in a link's query string or in a hidden form field or as a Set-Cookie header. The SID can be sent back from the client to the server as a query string parameter or in the body of the HTTP message if the post method is used or in a Cookie HTTP header.
• 
  
• If a cookie is not used to store the SID then the session will only last until the browser is closed, or the user goes to another site breaking the POST or query string transmission, or in other words, the session will last only until the user leaves the site.
• 
  
• * Cookie Based SID:
• 
  
• A cookie based session has the advantage that it lasts until the cookie expires and, as only the SID travels the net, it is faster and safer. The disadvantage is that the client must have cookies enabled.
• 
  
• The only particularity with the cookie used to set a session is its value:
• 
  
• # The sid will be a hash of the server time
• sid = sha.new(repr(time.time())).hexdigest()
• 
  
• The hash of the server time makes an unique SID for each session.
• 
  
• #!/usr/bin/env python
• 
  
• import sha, time, Cookie, os
• 
  
• cookie = Cookie.SimpleCookie()
• string_cookie = os.environ.get('HTTP_COOKIE')
• 
  
• # If new session
• if not string_cookie:
• # The sid will be a hash of the server time
• sid = sha.new(repr(time.time())).hexdigest()
• # Set the sid in the cookie
• cookie['sid'] = sid
• # Will expire in a year
• cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
• # If already existent session
• else:
• cookie.load(string_cookie)
• sid = cookie['sid'].value
• 
  
• print cookie
• print 'Content-Type: text/html\n'
• print '<html><body>'
• 
  
• if string_cookie:
• print '<p>Already existent session</p>'
• else:
• print '<p>New session</p>'
• 
  
• print '<p>SID =', sid, '</p>'
• print '</body></html>'
• 
  
• In every page the existence of the cookie must be tested. If it does not exist then redirect to a login page or just create it if a login or a previous state is not required.
• 
  
• * Query String SID;
• 
  
• Query string based session:
• 
  
• #!/usr/bin/env python
• 
  
• import sha, time, cgi, os
• 
  
• sid = cgi.FieldStorage().getfirst('sid')
• 
  
• if sid: # If session exists
• message = 'Already existent session'
• else: # New session
• # The sid will be a hash of the server time
• sid = sha.new(repr(time.time())).hexdigest()
• message = 'New session'
• 
  
• qs = 'sid=' + sid
• print """\
• Content-Type: text/html\n
• <html><body>
• <p>%s</p>
• <p>SID = %s</p>
• <p><a href="./set_sid_qs.py?sid=%s">reload</a></p>
• </body></html>
• """ % (message, sid, sid)
• 
  
• To mantain a session you will have to append the query string to all the links in the page.
• 
  
• Save this file as set_sid_qs.py and run it two or more times. Try to close the browser and call the page again. The session is gone. The same happens if the page address is typed in the address bar.
• 
  
• * Hidden Field SID;
• 
  
• The hidden form field SID is almost the same as the query string based one, sharing the same problems.
• 
  
• #!/usr/bin/env python
• 
  
• import sha, time, cgi, os
• 
  
• sid = cgi.FieldStorage().getfirst('sid')
• 
  
• if sid: # If session exists
• message = 'Already existent session'
• else: # New session
• # The sid will be a hash of the server time
• sid = sha.new(repr(time.time())).hexdigest()
• message = 'New session'
• 
  
• qs = 'sid=' + sid
• 
  
• print """\
• Content-Type: text/html\n
• <html><body>
• <p>%s</p>
• <p>SID = %s</p>
• <form method="post">
• <input type="hidden" name=sid value="%s">
• <input type="submit" value="Submit">
• </form>
• </body><html>
• """ % (message, sid, sid)
• 
  
• 
  
• * The shelve module;
• 
  
• Having a SID is not enough. It is necessary to save the session state in a file or in a database. To save it into a file the shelve module is used. The shelve module opens a file and returns a dictionary like object which is readable and writable as a dictionary.
• 
  
• # The shelve module will persist the session data
• # and expose it as a dictionary
• session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
• 
  
• 
  
• The SID is part of file name making it a unique file. The apache user must have read and write permission on the file's directory. 660 would be ok.
• 
  
• The values of the dictionary can be any Python object. The keys must be immutable objects.
• 
  
• # Save the current time in the session
• session['lastvisit'] = repr(time.time())
• 
  
• # Retrieve last visit time from the session
• lastvisit = session.get('lastvisit')
• 
  
• The dictionary like object must be closed as any other file should be:
• 
  
• session.close()
• 
  
• * Cookie and Shelve;
• 
  
• A sample of how to make cookies and shelve work together keeping session state at the server side:
• 
  
• #!/usr/bin/env python
• import sha, time, Cookie, os, shelve
• 
  
• cookie = Cookie.SimpleCookie()
• string_cookie = os.environ.get('HTTP_COOKIE')
• 
  
• if not string_cookie:
• sid = sha.new(repr(time.time())).hexdigest()
• cookie['sid'] = sid
• message = 'New session'
• else:
• cookie.load(string_cookie)
• sid = cookie['sid'].value
• cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
• 
  
• # The shelve module will persist the session data
• # and expose it as a dictionary
• session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
• 
  
• # Retrieve last visit time from the session
• lastvisit = session.get('lastvisit')
• if lastvisit:
• message = 'Welcome back. Your last visit was at ' + \
• time.asctime(time.gmtime(float(lastvisit)))
• # Save the current time in the session
• session['lastvisit'] = repr(time.time())
• 
  
• print """\
• %s
• Content-Type: text/html\n
• <html><body>
• <p>%s</p>
• <p>SID = %s</p>
• </body></html>
• """ % (cookie, message, sid)
• 
  
• session.close()
• 
  
• It first checks if there is a cookie already set. If not it creates a SID and attributes it to the cookie value. An expiration time of one year is established.
• 
  
• The lastvisit data is what is maintained in the session.  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
• 
  
•