Python has been an object-oriented language from day one. Because of this, creating and using classes and objects are downright easy. This chapter helps you become an expert in using Python's object-oriented programming support.

What is an object?

An object is an instance of a class. Now, that sentence is really short and very confusing. You will note that understanding what a class, and an instance are is essential to understanding the definition given. Getting this topic is very essential because creating your own classes is very important to maintaining your code, making your application easy to read and understand.

This is a very important topic in programming.

Understanding this concept in programming will help you organize and be able to reuse your own code over and over again. Reusing your code will in turn save you a lot of time while coding. One more thing, it will help you write concise and shorter codes.  This concept is in fact, the one upon which every python code you know is written because every 'thing' from strings to any other type you know in python is an object. So you will learn how to make or write your own data types using this classes, is that not amazing?

Creating Classes. 

You follow a particular syntax to create classes in every language, but the general idea is to create a blueprint or an outline of a particular module or class, define (def) it's various parts (functions or methods) and what in particular each of these functions or methods do. 

Declaring Objects.

After creating your class, you will require an object, which can "wear" or "take up" the form, attributes (characteristics) and methods(functions) of the class, this is the way to make your blueprint useful. You might find the idea a bit daunting at first, you may be asking, "how do I put all of these together?" Let's look at classes this way; you are human (an object of the human class or  an object of the human definition) and you have parts (functions or methods) and these parts perform specific actions, and some, even multiple actions. Let's take the hand for an example and let's assume for the purpose of getting this idea clearly, that you only use the hand to throw a ball. This implies that anytime you want to use the hand, you will need a ball. Because..? Of course, because as we agreed earlier, the hand is for throwing a ball.

Arguments/Parameters.

We agreed that we needed a ball to use the hand. Do not get so lost in the analogy, the hand is a part of the human class, so the hand represents a function. Now, the name given to the ball is an argument or a parameter. Our function needs a ball (a parameter) in order to throw. So, any time you call this function, you need to supply it with a ball. You will do this in Python like this:

"""Create an object of the human class and name it.
We are assuming the Human class has already been defined.
We will learn how to define a class ourselves later"""
Kofi =  Human()
# Now call the function and supply it with a ball
Kofi.hand('ball')

Default arguments.

Sometimes, during the creation of your class, you could provide a default argument to your function(s), so that whenever a user of your class calls that function without providing it with an argument, the function will go and pick up that default argument you provided to work with. Make this clear in your documentation so that the default behavior of your function will not be a surprise. Try this.

# importing the sys class
import sys
print("Hello")
sys.exit(0)

Now try this:

import sys
print("hello")
sys.exit()

So the first time, you supplied an argument and it worked fine, the next, you did not, it still did work fine. That is because, the one who created this function called "exit" from the class sys, supplied it with a default argument which gets supplied to the function in case you did not provide any argument like in the second case.

Always argue?

However, you will agree with me that not every function (part) should require an argument to work. And yes, it is not every function that we create that should require an argument. So you can create a function like that, which when called, it just does something without requiring the user to supply anything. Can you think of any situation like that? Let's try this: If I said to you: "polish", you should definitely ask me for an argument, that is "what should I polish?", but if I said "jump", you sure can do that without any questions. Let's put this in code. Note that what you see between the parenthesis is/are what we call arguments or parameters.

# Let's define our function called polish
# Which always needs an argument
def polish(item):
	print("polished ",item)

So, calling this function without providing an argument (what to polish) should raise an error. Now, let's create one that does not require anything.

# Creating a function that does not require argument.
def jump():
	print("Jumped")

 The above requires no argument at all, so providing one will raise an error.

Like this:

def area_of_triangle(base,height):
	answer = 0.5*base*height
	return answer

This is because, we typically do not print the value returned from a function but we use it for something else, we will like to leave that to whoever uses the function, whether the person would like to just print the "answer" to the console, pass it to another function, display it on a web-page or even pass it on to an artificial intelligence system, anything.

Putting it all together

Now, we can put all of these methods in one class, so when we create an object of that class, the object can perform all of these functions. So, we could define thousands of functions in one class and then create objects which will inherit these functions. You might already be guessing some powerful things you could use this ability for. It even gets much more exciting to know that there is the ability to inherit from other classes. So, a class can serve as a parent class to other classes who then become the child classes. the child classes "inherit" the abilities of their parent class and add their own abilities to those, explaining their power. We will talk about inheritance later, for now, lets create our own class, a Human class.

# Use the keyword class to begin and give it a name
class Human:

""" We then initialize the class using __init__ Function.
This gets called whenever a Human object is created"""
 
        # The __init__ Function with default argument
        # for the Name being Kojo
	def __init__(self,Name="Kojo"):
		self.name = Name
        
        # Function that returns the Name
	def get_name(self):
		return self.name

        # Function that is used to set a new name
	def set_name(self,Name):
		self.name = Name
		return self.name
         
        # Function that polishes a given item
	def polish(self,item):
		value_added = "polished"
		return item,value_added
       
        # Function that makes the object jump
	def jump(self):
		return self.name, "jumped"

""" Let's create an object of our class.
Remember our __init__ requires two arguments:
Which are self (the object we created, so it's already supplied
And a Name """

# Baby is the object and Kofi is the name
Baby = Human("Kofi")

# Let's get the name of our Human object that
# we referenced as Baby.

print(Baby.get_name())
>>>Kofi

From our __init__ method, we have provided a default Name for any object created, so if you created an object of our Human class without passing any Name, the get_name method will still return that default argument, whcih in this case is Kojo. But if you do provide a Name like in the above, then that Name will override the default Name(Kojo).

# Let's set a new name for our object Baby
print(Baby.set_name("Adwoa")
>>>Adwoa

The self argument gets supplied to our method anytime we call the object so there's no need to supply it ourselves. The get method is used to get attributes (characteristics, like Name in this case) of our object, in this case we wrote one that gets the Name of the object, there are in_built get methods, also the set methods are used to modify or change those attributes, we also wrote an example ourselves, which sets a new Name for our object. We then wrote two other methods, one is polish which takes an argument, particularly, the item to polish and returns a "polished" item. The other method is jump, which just makes the object jumps. So there, we have created our own class, provided our own getters and setters, and other methods. We also learnt how to create an object of our class and how to put that object in use.

Can you think of other methods you could add?

How about some other attributes apart from the Name?, like skin color, hair color...

FootNote: Some PEP8 rules were broken on purpose, this is to make codes clearer in our opinion and to make differentiating easier. In the case of the variable Naming, where we used "Name" instead of "name" is an example.

Further Readings

A class is an outline or a blueprint for creating an object. It is how an object will look like and how the various parts of that object will function. Imagine an outline for a car, not the car itself but the outline, the various parts that will move to move the whole car. All of these parts must be pre-defined and theoretically tested before creating the real object which is the physical car. So, the physical car is a manifestation of the "plan" (outline).

Classes help hide data that should not be accessible to the user from the user (data abstraction).

Using the car example, you realise that while using a car, let's focus on driving and loading your stuff inside the car as it's only usage (well, is there another usage?), you are allowed by the company that made the car directly be able to control some parts of the car and even have a handbook on how to effectively control these parts.

However, some parts of the car are a bit restricted because you will mess things up if you were an allowed easy access.

This is exactly the concept that classes help you achieve and also allow you to group functions of the same entity together. If you are wondering what these functions could be just think of the car example again: the functions will include accelerate, so whenever the user calls accelerate, the car moves forward, reverse, break, steer right, steer left among others.

Basically, this is the idea, when you create a class of a car, then you have created a car with all its functions but the car remains invisible and unusable until an object which is a physical manifestation of that car class is created. The object assumes all the definitions of that class, and performs all the functions defined in the class suite.

When I say human, you definitely have an idea what a human looks like and the things that a human can do - that is the class. Now, you will agree that every human have their unique features and abilities even though they all belong to the same blueprint (The Human Class).

In progrmming, this concept of every unique human being (object of the human class) having their own unique features is implemented by creating only one class but having as many objects of that class as possible and each object having their own unique features (class variables).

Inheriting features from an "older" class is allowed, just like you inherited some features from your Mum or Dad.

Did you get the point?

In beginning, I said an object is an instance of a class. do you get the point now? An object is an entity of a class, an object is the manifestation of a class. When I say this is a dog, you definitely have a blueprint or outline of a dog in your mind to agree or disagree with, so goes for any object, the object must have the features of it's class.

Now let's move on to some terminologies and their definitions before creating our own classes and objects.

Overview of OOP Terminology

• Class: A user-defined prototype for an object that defines a set of attributes that characterize any object of the class. The attributes are data members (class variables and instance variables) and methods, accessed via dot notation.
• Class variable: A variable that is shared by all instances of a class. Class variables are defined within a class but outside any of the class's methods. Class variables aren't used as frequently as instance variables are.
• Data member: A class variable or instance variable that holds data associated with a class and its objects.
• Function overloading: The assignment of more than one behavior to a particular function. The operation performed varies by the types of objects (arguments) involved.
• Instance variable: A variable that is defined inside a method and belongs only to the current instance of a class.
• Inheritance : The transfer of the characteristics of a class to other classes that are derived from it.
• Instance: An individual object of a certain class. An object obj that belongs to a class Circle, for example, is an instance of the class Circle.
• Instantiation: The creation of an instance of a class.
• Method: A special kind of function that is defined in a class definition.
• Object: A unique instance of a data structure that's defined by its class. An object comprises both data members (class variables and instance variables) and methods.
• Operator overloading: The assignment of more than one function to a particular operator.

Creating Classes

The class statement creates a new class definition. The name of the class immediately follows the keyword class followed by a colon as follows:

class ClassName:
   'Optional class documentation string'
   class_suite

The class has a documentation string, which can be accessed via ClassName.__doc__. The class_suite consists of all the component statements defining class members, data attributes and functions. Example: Following is the example of a simple Python class:

class Employee:
    #This is the docstring
   'Common base class for all employees'
    # class variable
   empCount = 0
    # initialization method
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
    #Other class methods
   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

The variable empCount is a class variable whose value would be shared among all instances of a this class. This can be accessed as Employee.empCount from inside the class or outside the class. The first method __init__() is a special method, which is called class constructor or initialization method that Python calls when you create a new instance of this class. You declare other class methods like normal functions with the exception that the first argument to each method is self. Python adds the self argument to the list for you; you don't need to include it when you call the methods.

Creating instance objects

To create instances of a class, you call the class using class name and pass in whatever arguments its __init__ method accepts.

#This would create first object of Employee class called Effie
Effie = Employee("Effie", 6000)
#This would create second object of Employee class called Ellie
Ellie = Employee("Ellie", 4000)

So, those two objects (emp1 and emp2) belong to the same class called Employee and have their unique features which differentiates one from the other. We created only one class but we could create two objects from that same class without wirting a class for the second object all over again. If there were a thousand Employees, we could just create a thousand objects from the same class with thier own Names and Salaries.

Accessing attributes

You access the object's attributes using the dot operator with object. Class variable would be accessed using class name as follows:

Effie.displayEmployee()
Ellie.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

Now, putting all the concepts together:

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

#This would create first object of Employee class called emp1
emp1 = Employee("Effie", 2000)
#This would create second object of Employee class called emp2
emp2 = Employee("Theo", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)
When the above code is executed, it produces the following result:

Name :  Effie ,Salary:  3000
Name :  Theo ,Salary:  5000
Total Employee 2
    

You can add, remove or modify attributes of classes and objects at any time:

emp1.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # Delete 'age' attribute.

Instead of using the normal statements to access attributes,you can use following functions:

The getattr(obj, name[, default]) : to access the attribute of object.

The hasattr(obj,name) : to check if an attribute exists or not.

The setattr(obj,name,value) : to set an attribute.
    If attribute does not exist, then it would be created.

The delattr(obj, name) : to delete an attribute.

hasattr(emp1, 'age')    # Returns true if 'age' attribute exists
getattr(emp1, 'age')    # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(empl, 'age')    # Delete attribute 'age'
    

Built-In Class Attributes

Every Python class keeps following built-in attributes and they can be accessed using dot operator like any other attribute: __dict__ : Dictionary containing the class's namespace. __doc__ : Class documentation string or None if undefined. __name__: Class name. __module__: Module name in which the class is defined. This attribute is "__main__" in interactive mode. __bases__ : A possibly empty tuple containing the base classes, in the order of their occurrence in the base class list. For the above class let's try to access all these attributes:

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__)
    

When the above code is executed, it produces the following result:

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
, 'empCount': 2,
'displayEmployee': ,
'__doc__': 'Common base class for all employees',
'__init__': }
            

Destroying Objects (Garbage Collection)

Python deletes unneeded objects (built-in types or class instances) automatically to free memory space. The process by which Python periodically reclaims blocks of memory that no longer are in use is termed garbage collection. Python's garbage collector runs during program execution and is triggered when an object's reference count reaches zero. An object's reference count changes as the number of aliases that point to it changes. An object's reference count increases when it's assigned a new name or placed in a container (list, tuple or dictionary). The object's reference count decreases when it's deleted with del, its reference is reassigned, or its reference goes out of scope. When an object's reference count reaches zero, Python collects it automatically.

a = 40      # Create object <40>
b = a       # Increase ref. count  of <40>
c = [b]     # Increase ref. count  of <40>

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40>
c[0] = -1   # Decrease ref. count  of <40>
    

You normally won't notice when the garbage collector destroys an orphaned instance and reclaims its space. But a class can implement the special method __del__(), called a destructor, that is invoked when the instance is about to be destroyed. This method might be used to clean up any nonmemory resources used by an instance. Example: This __del__() destructor prints the class name of an instance that is about to be destroyed:

class Point:
   def __init( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "destroyed"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # prints the ids of the obejcts
del pt1
del pt2
del pt3
    

When the above code is executed, it produces following result:

3083401324 3083401324 3083401324
Point destroyed
    

Class Inheritance

Instead of starting from scratch, you can create a class by deriving it from a preexisting class by listing the parent class in parentheses after the new class name. The child class inherits the attributes of its parent class, and you can use those attributes as if they were defined in the child class. A child class can also override data members and methods from the parent. Just the way you would inherit the physical features of your parents and even their properties.

Syntax

Derived classes are declared much like their parent class; however, a list of base classes to inherit from are given after the class name:

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

Example:

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print ("Calling parent constructor")

   def parentMethod(self):
      print ('Calling parent method')

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "Parent attribute :", Parent.parentAttr

class Child(Parent): # define child class
   def __init__(self):
      print ("Calling child constructor")

   def childMethod(self):
      print ('Calling child method')
       

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method
    

When the above code is executed, it produces the following result:

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200
    

Similar way, you can derive a class from multiple parent classes as follows:

class A:        # define your class A
.....

class B:         # define your calss B
.....

class C(A, B):   # subclass of A and B
.....
    

You can use issubclass() or isinstance() functions to check a relationships of two classes and instances. The issubclass(sub, sup) boolean function returns true if the given subclass sub is indeed a subclass of the superclass sup. The isinstance(obj, Class) boolean function returns true if obj is an instance of class Class or is an instance of a subclass of Class

Overriding Methods

You can always override your parent class methods. One reason for overriding parent's methods is because you may want special or different functionality in your subclass. Example:

class Parent:        # define parent class
   def myMethod(self):
      print ('Calling parent method')

class Child(Parent): # define child class
   def myMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.myMethod()         # child calls overridden method
    

When the above code is executed, it produces the following result:

Calling child method
    

Base Overloading Methods

Following table lists some generic functionality that you can override in your own classes:

Overloading Operators

Suppose you've created a Vector class to represent two-dimensional vectors, what happens when you use the plus operator to add them? Most likely Python will yell at you. You could, however, define the __add__ method in your class to perform vector addition and then the plus operator would behave as per expectation: Example:

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return ('Vector (%d, %d)' % (self.a, self.b))

   def __add__(self,other):
      return (Vector(self.a + other.a, self.b + other.b))

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

When the above code is executed, it produces the following result:

Vector(7,8)

Data Hiding

Remember we talked about hiding certain data from the user in order to prevent the user from messing up things? An object's attributes may or may not be visible outside the class definition. For these cases, you can name attributes with a double underscore prefix, and those attributes will not be directly visible to outsiders. Example:

class JustCounter:
   __secretCount = 0

   def count(self):
      self.__secretCount += 1
      print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.__secretCount)
    

When the above code is executed, it produces the following result:

1
2
Traceback (most recent call last):
  File "test.py", line 12, in 
    print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python protects those members by internally changing the name to include the class name. You can access such attributes as object._className__attrName. If you would replace your last line as following, then it would work for you: .........................

print (counter._JustCounter__secretCount)

When the above code is executed, it produces the following result:

1
2
2

You can specify different flags using bitwise OR (|).These are modifiers, which are listed in the table below.

   	        
    	        The re.match function returns a match object on success, None on failure. We would use group(num) or groups() function of match object to get matched expression.

    Match Object Methods	Description

    group(num=0)	        This method returns entire match (or specific subgroup num)

    groups()	            This method returns all matching subgroups in a tuple (empty if there weren't any)

import re

line = "Cats are smarter than dogs"

matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)

if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"
When the above code is executed, it produces following result:
matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

re.search(pattern, string, flags=0)

    Parameter	    Description
    pattern	        This is the regular expression to be matched.
    string	        This is the string, which would be searched to
                    match the pattern anywhere in the string.
    flags	        You can specify different flags using bitwise OR (|).
                    These are modifiers, which are listed in the table below.

Match Object Methods	Description
group(num=0)	        This method returns entire match (or specific subgroup num)
groups()	            This method returns all matching subgroups in a tuple (empty if there weren't any)

import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"
When the above code is executed, it produces following result:
matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print "match --> matchObj.group() : ", matchObj.group()
else:
   print "No match!!"

searchObj = re.search( r'dogs', line, re.M|re.I)
if searchObj:
   print "search --> searchObj.group() : ", searchObj.group()
else:
   print "Nothing found!!"
When the above code is executed, it produces the following result:
No match!!
search --> matchObj.group() :  dogs

re.sub(pattern, repl, string, max=0)

import re

phone = "2004-959-559 # This is Phone Number"

# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num

# Remove anything other than digits
num = re.sub(r'\D', "", phone)
print "Phone Num : ", num
When the above code is executed, it produces the following result:
Phone Num :  2004-959-559
Phone Num :  2004959559

Modifier	Description

    re.I	    Performs case-insensitive matching.

    re.L	    Interprets words according to the current locale. This interpretation affects the
                alphabetic group (\w and \W), as well as word boundary behavior (\b and \B).

    re.M	    Makes $ match the end of a line (not just the end of the string) and
                makes ^ match the start of any line (not just the start of the string).

    re.S	    Makes a period (dot) match any character, including a newline.

    re.U	    Interprets letters according to the Unicode character set.
                This flag affects the behavior of \w, \W, \b, \B.

    re.X	    Permits "cuter" regular expression syntax. It ignores whitespace (except
                inside a set [] or when escaped by a backslash) and treats unescaped # as a comment marker.

    Pattern	    Description

    ^	        Matches beginning of line.

    $	        Matches end of line.

    .	        Matches any single character except newline.
            Using m option allows it to match newline as well.

    [...]	    Matches any single character in brackets.

    [^...]	    Matches any single character not in brackets

    re*	        Matches 0 or more occurrences of preceding expression.

    re+	        Matches 1 or more occurrence of preceding expression.

    re?	        Matches 0 or 1 occurrence of preceding expression.

    re{ n}	    Matches exactly n number of occurrences of preceding expression.

    re{ n,}	    Matches n or more occurrences of preceding expression.

    re{ n, m}	Matches at least n and at most m occurrences of preceding expression.

    a| b	    Matches either a or b.

    (re)	    Groups regular expressions and remembers matched text.

    (?imx)	    Temporarily toggles on i, m, or x options within a regular
            expression. If in parentheses, only that area is affected.

    (?-imx)	    Temporarily toggles off i, m, or x options within a regular
            expression. If in parentheses, only that area is affected.

    (?: re)	    Groups regular expressions without remembering matched text.

    (?imx: re)	Temporarily toggles on i, m, or x options within parentheses.

    (?-imx: re)	Temporarily toggles off i, m, or x options within parentheses.

    (?#...)	    Comment.

    (?= re)	    Specifies position using a pattern. Doesn't have a range.

    (?! re)	    Specifies position using pattern negation. Doesn't have a range.

    (?> re)	    Matches independent pattern without backtracking.

    \w	        Matches word characters.

    \W	        Matches nonword characters.

    \s	        Matches whitespace. Equivalent to [\t\n\r\f].

    \S	        Matches nonwhitespace.

    \d	        Matches digits. Equivalent to [0-9].

    \D	        Matches nondigits.

    \A	        Matches beginning of string.

    \Z	        Matches end of string. If a newline exists, it matches just before newline.

    \z	        Matches end of string.

    \G	        Matches point where last match finished.

    \b	        Matches word boundaries when outside brackets.
                Matches backspace (0x08) when inside brackets.

    \B	        Matches nonword boundaries.

    \n, \t, etc.	Matches newlines, carriage returns, tabs, etc.

    \1...\9	        Matches nth grouped subexpression.

    \10	            Matches nth grouped subexpression if it matched already.
                     Otherwise refers to the octal representation of a character code.

Example	        Description
python	        Match "python".

    Example	        Description

    [Pp]ython	    Match "Python" or "python"

    rub[ye]	        Match "ruby" or "rube"

    [aeiou]	        Match any one lowercase vowel

    [0-9]	        Match any digit; same as [0123456789]

    [a-z]	        Match any lowercase ASCII letter

    [A-Z]	        Match any uppercase ASCII letter

    [a-zA-Z0-9]	    Match any of the above

    [^aeiou]	    Match anything other than a lowercase vowel

    [^0-9]	        Match anything other than a digit

    Example	        Description

    .	            Match any character except newline

    \d	            Match a digit: [0-9]

    \D	            Match a nondigit: [^0-9]

    \s	            Match a whitespace character: [ \t\r\n\f]

    \S	            Match nonwhitespace: [^ \t\r\n\f]

    \w	            Match a single word character: [A-Za-z0-9_]

    \W	            Match a nonword character: [^A-Za-z0-9_]

    Example	    Description

    ruby?	    Match "rub" or "ruby": the y is optional

    ruby*	    Match "rub" plus 0 or more ys

    ruby+	    Match "rub" plus 1 or more ys

    \d{3}	    Match exactly 3 digits

    \d{3,}	    Match 3 or more digits

    \d{3,5}	    Match 3, 4, or 5 digits

    Example	    Description

    <.*>	    Greedy repetition: matches "perl>"

    <.*?>	    Nongreedy: matches "" in "perl>"
    

    Example	    Description

    \D\d+	    No group: + repeats \d

    (\D\d)+	    Grouped: + repeats \D\d pair

    ([Pp]ython(, )?)+	Match "Python", "Python, python, python", etc.

    Example	                Description

    ([Pp])ython&\1ails	    Match python&pails or Python&Pails

    (['"])[^\1]*\1	        Single or double-quoted string. \1 matches whatever the 1st group matched .
                            \2 matches whatever the 2nd group matched, etc.
    

    Example	        Description

    python|perl	    Match "python" or "perl"

    rub(y|le))  	Match "ruby" or "ruble"

    Python(!+|\?)	"Python" followed by one or more ! or one ?

    Example	    Description

    ^Python	    Match "Python" at the start of a string or internal line

    Python$	    Match "Python" at the end of a string or line

    \APython	Match "Python" at the start of a string

    Python\Z	Match "Python" at the end of a string

    \bPython\b	Match "Python" at a word boundary

    \brub\B	    \B is nonword boundary: match "rub" in "rube" and "ruby" but not alone

    Python(?=!)	Match "Python", if followed by an exclamation point

    Python(?!!)	Match "Python", if not followed by an exclamation point
    

    Example	        Description

    R(?#comment)	Matches "R". All the rest is a comment

    R(?i)uby	    Case-insensitive while matching "uby"

    R(?i:uby)	    Same as above

    rub(?:y|le))	Group only without creating \1 backreference

    # This is server.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.
s.bind((host, port))        # Bind to the port

s.listen(5)                 # Now wait for client connection.
while True:
   c, addr = s.accept()     # Establish connection with client.
   print 'Got connection from', addr
   c.send('Thank you for connecting')
   c.close()                # Close the connection

# This is client.py file

import socket               # Import socket module

s = socket.socket()         # Create a socket object
host = socket.gethostname() # Get local machine name
port = 12345                # Reserve a port for your service.

s.connect((host, port))
print s.recv(1024)
s.close                     # Close the socket when done

# Following would start a server in background.
$ python server.py &

# Once server is started run client as follows:

$ python client.py

Got connection from ('127.0.0.1', 48437)
Thank you for connecting
Python Internet modules

import thread
import time

# Define a function for the thread
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print "%s: %s" % ( threadName, time.ctime(time.time()) )

# Create two threads as follows
try:
   thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print "Error: unable to start thread"

while 1:
   pass
    

Thread-1: Thu Jan 22 15:42:17 2009
Thread-1: Thu Jan 22 15:42:19 2009
Thread-2: Thu Jan 22 15:42:19 2009
Thread-1: Thu Jan 22 15:42:21 2009
Thread-2: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:23 2009
Thread-1: Thu Jan 22 15:42:25 2009
Thread-2: Thu Jan 22 15:42:27 2009
Thread-2: Thu Jan 22 15:42:31 2009
Thread-2: Thu Jan 22 15:42:35 2009

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print "Starting " + self.name
        print_time(self.name, self.counter, 5)
        print "Exiting " + self.name

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            thread.exit()
        time.sleep(delay)
        print "%s: %s" % (threadName, time.ctime(time.time()))
        counter -= 1

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

print "Exiting Main Thread"
When the above code is executed, it produces the following result:
Starting Thread-1
Starting Thread-2
Exiting Main Thread
Thread-1: Thu Mar 21 09:10:03 2013
Thread-1: Thu Mar 21 09:10:04 2013
Thread-2: Thu Mar 21 09:10:04 2013
Thread-1: Thu Mar 21 09:10:05 2013
Thread-1: Thu Mar 21 09:10:06 2013
Thread-2: Thu Mar 21 09:10:06 2013
Thread-1: Thu Mar 21 09:10:07 2013
Exiting Thread-1
Thread-2: Thu Mar 21 09:10:08 2013
Thread-2: Thu Mar 21 09:10:10 2013
Thread-2: Thu Mar 21 09:10:12 2013
Exiting Thread-2
    

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print "Starting " + self.name
        # Get lock to synchronize threads
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # Free lock to release next thread
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print "%s: %s" % (threadName, time.ctime(time.time()))
        counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()
print "Exiting Main Thread"
When the above code is executed, it produces the following result:
Starting Thread-1
Starting Thread-2
Thread-1: Thu Mar 21 09:11:28 2013
Thread-1: Thu Mar 21 09:11:29 2013
Thread-1: Thu Mar 21 09:11:30 2013
Thread-2: Thu Mar 21 09:11:32 2013
Thread-2: Thu Mar 21 09:11:34 2013
Thread-2: Thu Mar 21 09:11:36 2013
Exiting Main Thread

import Queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def run(self):
        print "Starting " + self.name
        process_data(self.name, self.q)
        print "Exiting " + self.name

def process_data(threadName, q):
    while not exitFlag:
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print "%s processing %s" % (threadName, data)
        else:
            queueLock.release()
        time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1

# Create new threads
for tName in threadList:
    thread = myThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

# Fill the queue
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

# Wait for queue to empty
while not workQueue.empty():
    pass

# Notify threads it's time to exit
exitFlag = 1

# Wait for all threads to complete
for t in threads:
    t.join()
print "Exiting Main Thread"
When the above code is executed, it produces the following result:
Starting Thread-1
Starting Thread-2
Starting Thread-3
Thread-1 processing One
Thread-2 processing Two
Thread-3 processing Three
Thread-1 processing Four
Thread-2 processing Five
Exiting Thread-3
Exiting Thread-1
Exiting Thread-2
Exiting Main Thread

import smtplib
smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

import smtplib

sender = 'from@fromdomain.com'
receivers = ['to@todomain.com']

message = """From: From Person 
To: To Person 
Subject: SMTP e-mail test

This is a test e-mail message.
"""

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, receivers, message)
   print "Successfully sent email"
except SMTPException:
   print "Error: unable to send email"

import smtplib

message = """From: From Person 
To: To Person 
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP HTML e-mail test

This is an e-mail message to be sent in HTML format

This is HTML message.

import smtplib
import base64

filename = "/tmp/test.txt"

# Read a file and encode it into base64 format
fo = open(filename, "rb")
filecontent = fo.read()
encodedcontent = base64.b64encode(filecontent)  # base64

sender = 'webmaster@tutorialpoint.com'
reciever = 'amrood.admin@gmail.com'

marker = "AUNIQUEMARKER"

body ="""
This is a test email to send an attachement.
"""
# Define the main headers.
part1 = """From: From Person 
To: To Person 
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=%s
--%s
""" % (marker, marker)

# Define the message action
part2 = """Content-Type: text/plain
Content-Transfer-Encoding:8bit

%s
--%s
""" % (body,marker)

# Define the attachment section
part3 = """Content-Type: multipart/mixed; name=\"%s\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename=%s

%s
--%s--
""" %(filename, filename, encodedcontent, marker)
message = part1 + part2 + part3

try:
   smtpObj = smtplib.SMTP('localhost')
   smtpObj.sendmail(sender, reciever, message)
   print "Successfully sent email"
except Exception:
   print "Error: unable to send email"

import Tkinter
top = Tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()
    

    static PyObject *MyFunction( PyObject *self, PyObject *args );

static PyObject *MyFunctionWithKeywords(PyObject *self,
                                 PyObject *args,
                                 PyObject *kw);

static PyObject *MyFunctionWithNoArgs( PyObject *self );

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}
    

struct PyMethodDef {
   char *ml_name;
   PyCFunction ml_meth;
   int ml_flags;
   char *ml_doc;
};
    

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};
    

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
    

#include 

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Do your stuff here. */
   Py_RETURN_NONE;
}

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { NULL, NULL, 0, NULL }
};

PyMODINIT_FUNC initModule() {
   Py_InitModule3(func, module_methods, "docstring...");
}
    

#include 

static PyObject* helloworld(PyObject* self)
{
    return Py_BuildValue("s", "Hello, Python extensions!!");
}

static char helloworld_docs[] =
    "helloworld( ): Any message you want to put here!!\n";

static PyMethodDef helloworld_funcs[] = {
    {"helloworld", (PyCFunction)helloworld,
     METH_NOARGS, helloworld_docs},
    {NULL}
};

void inithelloworld(void)
{
    Py_InitModule3("helloworld", helloworld_funcs,
                   "Extension module example!");
}
    

setup(name='helloworld', version='1.0',  \
      ext_modules=[Extension('helloworld', ['hello.c'])])

import helloworld

print helloworld.helloworld()

Hello, Python extensions!!

static PyObject *module_func(PyObject *self, PyObject *args) {
   /* Parse args and do something interesting here. */
   Py_RETURN_NONE;
}
    

static PyMethodDef module_methods[] = {
   { "func", (PyCFunction)module_func, METH_NOARGS, NULL },
   { "func", module_func, METH_VARARGS, NULL },
   { NULL, NULL, 0, NULL }
};
    

static PyObject *module_func(PyObject *self, PyObject *args) {
   int i;
   double d;
   char *s;

   if (!PyArg_ParseTuple(args, "ids", &i, &d, &s)) {
      return NULL;
   }

   /* Do something interesting here. */
   Py_RETURN_NONE;
}
    

module.func(1, s="three", d=2.0)
module.func(i=1, d=2.0, s="three")
module.func(s="three", d=2.0, i=1)

int PyArg_ParseTuple(PyObject* tuple,char* format,...)

static PyObject *foo_add(PyObject *self, PyObject *args) {
   int a;
   int b;

   if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
      return NULL;
   }
   return Py_BuildValue("i", a + b);
}

    def add(a, b):
        return (a + b)
    

    static PyObject *foo_add_subtract(PyObject *self, PyObject *args) {
        int a;
        int b;

    if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
          return NULL;
    }
        return Py_BuildValue("ii", a + b, a - b);
    }
    

def add_subtract(a, b):
   return (a + b, a - b)
    

PyObject* Py_BuildValue(char* format,...)
    

 
{...} builds dictionaries from an even number of C values, alternately keys and values. For example, Py_BuildValue("{issi}",23,"zig","zag",42) returns a dictionary like Python's {23:'zig','zag':42}.

import dis

def sum():
   vara = 10
   varb = 20

   sum = vara + varb
   print "vara + varb = %d" % sum

# Call dis function for the function.

dis.dis(sum)

  6           0 LOAD_CONST               1 (10)
              3 STORE_FAST               0 (vara)

  7           6 LOAD_CONST               2 (20)
              9 STORE_FAST               1 (varb)

  9          12 LOAD_FAST                0 (vara)
             15 LOAD_FAST                1 (varb)
             18 BINARY_ADD
             19 STORE_FAST               2 (sum)

 10          22 LOAD_CONST               3 ('vara + varb = %d')
             25 LOAD_FAST                2 (sum)
             28 BINARY_MODULO
             29 PRINT_ITEM
             30 PRINT_NEWLINE
             31 LOAD_CONST               0 (None)
             34 RETURN_VALUE

> /test/sum.py(3)()
-> import dis
(Pdb) n
> /test/sum.py(5)()
-> def sum():
(Pdb) n
>/test/sum.py(14)()
-> dis.dis(sum)
(Pdb) n
  6           0 LOAD_CONST               1 (10)
              3 STORE_FAST               0 (vara)

  7           6 LOAD_CONST               2 (20)
              9 STORE_FAST               1 (varb)

  9          12 LOAD_FAST                0 (vara)
             15 LOAD_FAST                1 (varb)
             18 BINARY_ADD
             19 STORE_FAST               2 (sum)

 10          22 LOAD_CONST               3 ('vara + varb = %d')
             25 LOAD_FAST                2 (sum)
             28 BINARY_MODULO
             29 PRINT_ITEM
             30 PRINT_NEWLINE
             31 LOAD_CONST               0 (None)
             34 RETURN_VALUE
--Return--
> /test/sum.py(14)()->None
-v dis.dis(sum)
(Pdb) n
--Return--
> (1)()->None
(Pdb)
    

vara = 10
varb = 20

sum = vara + varb
print "vara + varb = %d" % sum
Now, try running cProfile.py over this file sum.pyas follows:
$cProfile.py sum.py
vara + varb = 30
         4 function calls in 0.000 CPU seconds

   Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno
   1    0.000    0.000    0.000    0.000 :1()
   1    0.000    0.000    0.000    0.000 sum.py:3()
   1    0.000    0.000    0.000    0.000 {execfile}
   1    0.000    0.000    0.000    0.000 {method ......}

vara = 10
varb = 20

sum = vara + varb
print "vara + varb = %d" % sum
    

$tabnanny.py -v sum.py
'sum.py': Clean bill of health.