Python - Basics- Learn the Python with Examples

In this post, you can find the basics of python.

Run "python" from any Linux terminal (or shell) and practice all examples mentioned below.

-------------
Operations:
--------------

+, -, %, *

2**3 = 2 power 3 = 8

--------
Varibles
--------

Variables is used to store the values.

x=6
y=8

print (x+y)


How to read from keyboard
-------------------------

x=input("enter the Number here ')

print x


Modules and functions
----------------------

x=abs(16)

y=pow(2)

How import to module
=================

import math

The respective module can be accessed by using <modulename>.function

math.floor(18.7) = 18

-------
Strings
========

strings can be stored as " " or ' '

But if there is a string like 'he's muni' -> Error

to avoid these kind of issues then use "he's muni"

Escape Character (\)
-------------------
'he\'s muni' -> it is going to escape next character.

another example
'bucky said, "hey now " to me' -> Solution is: 'bucky said, \"hey now\" to me'

Joining Strings or Concatenation of strings (+)
============================================

a= "muni"
b= "sekhar"

print a + b => munisekhar

'+' sign is used to concatenate the string or Join the strings.


How to concatenate the string and integer
-----------------------------------------

num = 18
print "hello world " + num  -> Will lead in to error.

Since the integer can be concatenate with the string, so we need to convert
the integer in to string.

1 way : str(num)  -> convert num to string.

print "hello world" + str(num)

2nd way: `num`

print "hello world" + `num`

3rd way: repr(num)

print "hello world" + repr(num)


Difference between raw_input vs input
-------------------------------------

raw_input-> Generally used for string. It takes input and converts in to string

input -> Generally used for math(numbers), it can't be used for strings

ex:

bucky = input("Enter the number")
print bucky

>> After execute: Enter the number
>>> muni

--------> lead to error.

Correct way of doing is:
-----------------------
bucky = raw_input("Enter the number")
print bucky

Enter the number
muni

output : muni

=====================
Sequences and Lists
=====================


The most basic datastructure in python is sequence - Each element in a sequence is
assigned with number - It's position or index.
index starts from zero..

The list is a most versatile datatype available in Python which can be written as a list of
comma-separated values (items) between square brackets.
Important thing about a list is that items in a list need not be of the same type.

lists:
-----

list1 = ["muni", "sekhar", 12, 34]

print list1[0]

output: muni

print list[3]

output: 34

How to print the end of the list: It always start from -1.
---------------------------------
print list[-1]  

output: 34

strings indexing
-----------------

str = "muni"

print str[0]   -> m
      str[1]   -> u


==========
slicing
=========

slicing can be done using ':' (colon) operator

example = [0,1,2,3 4,5,6,7,8, 9]

print example[0:4]

output: 0,1,2,3

It explains as include start of the element and print before the end (Here 4 is not included).

example = [0,1,2,3 4,5,6,7,8, 9]

print example[1:9]

[1,2,3,4,5,6,7,8]

How to include the last element
-------------------------------
print example[1:10]

or

print example[1:]

[1,2,3,4,5,6,7,8,9]


print example[:9] = [0,1,2,3,4,5,6,7,8,9]


How to print the element by adding 2
-------------------------------------

print example[1:9:2]  -> it increment every digit by 2.

[1,3,5,7]


print example[-5:9:2]  -> it increment every digit by 2.

[5,7]

Last digit is -1 i.e. 9

print example[-1:-4:-2]  -> it increment every digit by 2.

[9,7]

Double colon Operator
----------------------

example[::-2]
[9, 7, 5, 3, 1]

example[::2]
[0, 2, 4, 6, 8]

===================
Editing Sequencing
===================

The list can be concatenated using '+' operator

list1 = [1,2,3,4]
list2 = [5,6,7,8]

list 3 = list1 + list2

print list3

output : [1,2,3,4,5,6,7,8]

Mutiplication
--------------
num= 20

print num*2

Output -> 40

Double the list (repeat the number)
------------------------------------

num = [20]
print num*2

output -> [20,20]


list3*2 = [[1,2,3,4,5,6,7,8, 1,2,3,4,5,6,7,8]

===================
Using "in" Keyword
===================
"in" keyword is used to check whether the value or character present in the
list or string.

example 1:
---------

name = "muni"

if('r' in name) :
print "true"
else :
print "false"

->
Output : false

name = "muni"
if('m' in name):
  print "true"
else:
  print "false"

->
Output : true

example 2:

list = [1,2,3,4,5,6,7,8,9]
if(10 in list):
  print "true"
else:
  print "false"

->
Output : false

====================================
Some of the Useful List Functions
====================================

list1 = [1,2,3,4,5,6,7,8]

length function
----------------

print len(list1)

->
Output : 8

Get the Maxium value of the list
--------------------------------
print max(list1)

->
Output : 8

Get the Minimum value of the list
--------------------------------
print min(list1)

->
Output : 1

Change the List sequence number to different one
-------------------------------------------------

list1[3] = 10

print list1

->
Output : [1,2,3,10,5,6,7,8]

How to del particular number in a list(Use del keyword)
-------------------------------------------------------

del list1[3]

print list1

->
Output : [1,2,3,5,6,7,8]

-----------------------------
Convert the string in to list
-----------------------------

str = "bucky"

print list(str)

output:

['b','u', 'c','k','y']

===============
Slicing Lists
===============

example = list("bucket")

print example

Output->
['b', 'u', 'c', 'k', 'e', 't']

Append or replace the sequence of strings
==========================================
The below will replace letters from index=3 onwards

example[3:] = list("munisekhar")

print example

['b', 'u', 'c', 'm', 'u', 'n', 'i', 's', 'e', 'k', 'h', 'a', 'r']


Appending the list
===================

Below example append the list from position 1 to after 1

example = [0,1,2,3,4,5,6,7]

example[1:1] =[3,3,3]

print example

->
Output = [0,3,3,3,1,2,3,4,5,6,7]


example = [0,1,2,3,4,5,6,7]

example[2:4] = [10,11,12]

print example

->
Output = [0,1,10,11,12,4,5,6,7]



How to delete the list elements using Slicing operator
======================================================

example = [0,1,2,3,4,5,6,7]

example[1:5]   means starts from 1 to 4 (before 5)

example [1:5] = []

print example

->
Output = [0,5,6,7]

=========================
Introduction to methods
==========================

object.actionfunction(arguments)

for example:

myface.punch(hand) -> myface is the object
                     punch is the action
                     hand is the argument.


fruitslist = ['apples', 'jackfruit', 'banana', 'guava']

append
-------
is used to add the 'orange' string at the end of the list.
------
fruitslist.append('orange')

->
output:
>>> fruitslist = ['apples', 'jackfruit', 'banana', 'guava']
>>> fruitslist.append('orange')
>>> print fruitslist
['apples', 'jackfruit', 'banana', 'guava', 'orange']

-----
count  : How many times the element (string) present in the list.
-----
fruitslist.count('apples')

-------
Output
->
1

--------
extend
--------
one = [1,2,3]
two = [4,5,6]

one.extend(two)

print one

output->
The extend will take two list as a paramter and added to the one list.
[1,2,3,4,5,6]


Some more functions
-------------------

say =['muni', 'sekhar', 'reddy', 'a']

index  : to get the exact index number
======
say.index('reddy')

print say

output
->
-------
2

------
insert  : you can insert the data at particular index of list
------
say.insert(2, 'rishi')

print say

->
output:
['muni', 'sekhar', 'rishi', 'reddy', 'a']

----
pop  : remove the data using index
----

say.pop(2)

print say

->
output:
['muni', 'sekhar', 'reddy', 'a']

-------
remove  : pass the exact data to remove from the list
-------

say.remove('a')

print say

->
output:
['muni', 'sekhar', 'reddy']

--------
reverse  : reverser the list
--------
say.reverse()

->
output:
['reddy', 'sekhar', 'muni']

==================
Sort and Tuples
==================

Sort -> Using sort function, the list can be sorted.

new = [33, 5, 4,66,9,10]

new.sort()

print new

->
output:
[4,5,9,10,33,66]


String can be sorted using "sorted" keyword
============================================
name="muni"
sorted(name)

->
output:
['i','n','m','u']

-------

Tuples
======

For tuples , we can add or insert or modify the values in the tuples.

But whereas in list, the values can be modified.

buckytuple = (22,33,44,56)

bucky[2] = 44

tuples can't be modified.


================
String n Stuff
================

There are many useful string techniques, some of them are:

How to add your add content in the strings  (Using % operator)
------------------------------------------

bucky = " hey there %s, How are %s"

declare a tuple
----
var = ('ramu', 'sita')

The own content can be added using "%" operator.

print bucky % var

->
output:
hey there ramu, How are sita
-----------------------------------------
The same can be changed as:

varc = ('ra', 'si')

print bucky % varc

->
output:
hey there ra, How are si


Find Method for strings
========================

bucky = "are you there muni" , i am in cgiri"

bucky.find('muni')
->
output  : 14

'm' is at position of 14.


Some more String methods:
=========================

join the strings -> Using join keyword
----------------
sequence = ['hey' , 'there', 'boss']
glue = 'hoss'

glue.join(sequence)

output->
heyhosstherehossbosshoss

How to lower case the string (Using lower keyword)
----------------------------

randstr = "I am WORK women"
randstr.lower()

output->
i am work women

How to replace a string ( Using replace keyword)
------------------------
samplestring = " I am munisekhar Reddy"

samplestring.replace('Reddy', 'naidu')

Output-> I am munisekhar naidu



DICTIONARY
===========

dictionary is collection of keys and values.

" The values can be stored against the words"

syntax:
sampledictinary = {key:values}

sampledictionary = {'dad':'munireddy', 'mother':'aruna', 'grandmother':'gangamma'}

sampledictionary['dad']

output-> 'munireddy'

Some of the useful methods of dictonaries
------------------------------------------

clear method
-----

sampledictionary.clear()

clear the dictionary content and make the dictionary as empty.

output->
{}

Copy the dictionary
--------------------
anotherdict=sampledictionary.copy()

output->
anotherdict = {dad':'munireddy', 'mother':'aruna', 'grandmother':'gangamma'}

Check the dictonary has key or not
----------------------------------

sampledictionary.has_key('sister')

output->
false

sampledictionary.has_key('dad')

output->
true

=============
IF statement
=============

syntax:

if() :  (After end of if there is colon operator needs to give here)
  <indent> print sample
else :
  <indent> print else.



Sample example->

tuner = "blackcolour"
if(tuner == "blackcolor"):
   print " I am in IF loop"
else :
   print " I am in else loop"

=======================
IF/ELIF/ELSE statement
=======================
tuner = "blackcolour"

if(tuner == "blackcolour"):
  print " I am in IF loop"
elif (tuner == "redcolour"):
  print " I am in  red loop"
elif (tuner == "yellow"):
  print " i am in Yellow"
else :
  print " I am in else loop

=====================
NESTED IF statements
=====================
tuner = "redcolour"
animal = "pig"

if(tuner == "blackcolour"):
  print " I am in IF loop"

  /* Nested IF statements, IF statements within IF */
  if animal == pig:
     print " i am in pig"
  else :
     print " i am not pig"

elif (tuner == "redcolour"):
  print " I am in  red loop"

elif (tuner == "yellow"):
  print " i am in Yellow"

else :
  print " I am in else loop


=======================
Comparision Statements
======================

is and in statements in IF statements
-------------------------------------

in operator   ( It checks whether that element is present in the string)
------------

example = "pizza"

if 'p' in example:
  print true
else :
  print false

Output-> true.


is operator
------------

Whether it is same object or not.

list1 = [120,20]
list2=[120,20]

if (list1 is list2):
  print true
else :
  print false

Output-> false

since it is not same object.

example 2
----
list1 = list2= [120,20]
if (list1 is list2):
  print true
else :
  print false

Output-> true

=====================
And and Or operators
=====================
and -> Used for Range operation checks
or  -> either one is true


e.g:

example =3

if example<4 and example<6 :
  print "The AND condition is true"
elif example>19 or example<23:
  print "The OR condition is true"
else:
  print "nothing is matching"

====================
FOR and WHILE Loops
====================

While Loop example
------------------

b=1
while b<10:
  print "count:" + b
  b= b+1

Output-> count: 1,2 3,4 5,6,7,8,9


For Loop example
-----------------

fruitlist= ["milk", "juice ","butter"]
for food in fruitlist:
  print "I want " + food

Note: food will be pointing to the staring element of the list.
      There is no need to assigment of this variable also no need of increment.

 

Output->

I want milk
I want juice
I want butter

==================================
Infinite Loops and break statement
===================================

Let's have a dictionary which stores the values against the keys.

ages = {'dad':24, 'mom':45, 'sister':18}

for item in ages:
 print item

Output->
  item will be the keys of the dictionary.

dad
mom
sister


Then How to get the values of the dictionary
--------------------------------------------

ages = {'dad':24, 'mom':45, 'sister':18}

for item in ages
 print item, ages[item]

Output:

  dad    24
  mom    45
  sister 18
---------------
Infinite Loops
--------------

while 1:
  num=input("Enter the number")
  if num == 5:
    print "exit"
    break


example 2:
----------

while 1:
  name= raw_input("Enter the name")
  if(name =='quit'):
    break
 
Output:
Enter the name muni
Enter the name sekhar
Enter the name reddy
Enter the name quit


======================
Building functions
======================

How to write your own functions:

Use the keyword as "def" before the function name (def is called as definition).

function syntax:

def funcname(<parameters>):
  do some logic
  return parmeter

---------
example 1:
----------
def firstfunction(x):
 return "I want " +x

print firstfunction('cofee')
print firstfunction('Tea')
print firstfunction('milk')

Output->
I want cofee
I want Tea
I want milk


---------
example 2:
----------

def firstfunction(x):
 return  x+10

print firstfunction(10)
print firstfunction(20)
print firstfunction(30)

Output->
I want 10
I want 20
I want 30


==============================
Default parameters in function
==============================

def samplefunc(first= 'muni', last='sekhar'):
  print '%s %s' % (first, last)

firstfunction()

Output-> muni sekhar

In the above example, there are default values are assigned to the parameters.

function is called with out arguments. It prints the default values.

ex 2:
----
one can also override the default parameters as:

def samplefunc(first= 'muni', last='sekhar'):
  print '%s %s' % (first, last)

firstfunction('raj', 'reddy')

Output-> raj reddy


ex 3:
----
You can override the one parameter as:

def samplefunc(first= 'muni', last='sekhar'):
  print '%s %s' % (first, last)

firstfunction(last='reddy')

Output-> muni reddy

=====================
Multiple arguments
=====================

How to accept multiple arguments using single variable in a function

Use asterik (*)

ex 1:
-----

def samplefunc(*food):
  print food

samplefunc('apples', 'banana', 'cherrys')

Output->
(apples', 'banana', 'cherrys',)

Here the '*' infront of variable accept the multiple parameters (as tuple).


ex 2:
-----

def samplefunc(name, *ages):
  print name
  print ages

samplefunc('muni', (22,33,44,55))

Output->
muni, ((22, 33,44,55),)


=============================================
How to convert the parameters as dictionaries
==============================================

Double asterik (**) will do the magic.

example 1:
---------

def cart(**items):
  print items


cart(apple=40, grapes=65, strawberryies=89)

output-> Convert in to dictionaries
   {'apple':40, 'grapes':65, 'strawberryies':89

Note :apple=40 : equal sign makes key = value by compiler.

example 2:
---------
def cart(first, last, *ages, **items):
  print first
  print last
  print ages
  print items


cart('muni', 'sekhar', 22,33,44,55, apple=40, grapes=65, strawberryies=89)

equal sign  makes the compiler to think as dictionary.

output->  
muni
sekhar
(22,33,44,55)  (tuple)
{'apple':40, 'grapes':65, 'strawberryies':89} (dictionary)

==================================
Tuple and Dictionary as parameters
==================================

* (single asterik) is used for tuple
** (double asterik) is used for dictionary.


tuple as paramter:

--------------------------------------
def tupleparameter(a, b,c):
 return a+b*c

sampletuple = (1,2,3)

print tupleparameter(*sampletuple)

Output -> 7

Here a takes value a=1, b=2, c=3
-----------------------------------

dictionary as paramter:
----------------------

def dict(**example):
 print example

sampledict = {'dad':45, 'mom':55, 'sekhar':60}

dict(**sampledict)

===================
CLASSES and SELF
===================
 class contains data members and method.

 In methods the first parameter is "self" followed by parameters,

self
----
 self is the temporary holder for object name. The respective object is stored in self.

class syntax:
-------------
class <classname>:
 

  def method1 (self, x, y):
    statements

  def method2 (self, x, y):
    statements
 

#how to create object.
firstobj = classname()

How to access the method using the object?
-----------------------------------------
firstobj.method1()
firstobj.method2()


--------
example 1:
---------

class firstclass:
 def create(self, name, salary):
    self.name = name
    self.salary=salary

 def display(self):
    print "name : %s and salary: %d" % (self.name, self.salary)

# create object
firstobj= firstclass()
secondobj = firstclass()
firstobj.create('sekhar', 20)
secondobj.create('muni', 10)

firstobj.display()
firstobj.display()

============================
Super Class and Sub Classes
============================

class parentclass:
  var1="method"
  var2 ="methos2"
----------------------------------------
syntax: class derivedclass(parentclass):
----------------------------------------
#derived class
class derivedclass(parentclass):
  pass  (no definition or NULL statement, definition can be written later).


pass keyword:
------------
In Python programming, pass is a null statement. The difference between a comment and pass statement in Python is that, while the interpreter ignores a comment entirely,
pass is not ignored. But nothing happens when it is executed. It results into no operation (NOP).

---------------------
parentobj= parentclass()
print parentobj.var1

derivedobj= derivedclass()
print derivedobj.var1

---------
example :
---------
class parentclass:
  var1="first variable"
  var2="second variable"

class derivedclass(parentclass):
  pass #no definition

parentobj= parentclass()
print parentobj.var1
print parentobj.var2

derivedobj=derivedclass()
print derivedobj.var1
print derivedobj.var2
`

output->
first variable
second variable

first variable
second variable

=====================================
Overwrite Variables in derived class
=====================================
Python provides a flexibity to overwrite variables in the derived class.

class parentclass:
 var1="muni"
 var2="sekhar"

class derived(parentclass):
  var2="reddy"

pobj = parentclass()
print pobj.var1
print pobj.var2

print "derived class"
cobj = derived()
print cobj.var1
print cobj.var2

Output->
muni
sekhar

derived class
muni
reddy


=========================
Multiple Parent Classes
=========================

In python the derived class can inherit the properties from multiple classes.

Suppose if you have two classes  Mom and dad, the derived class (child) can inherit from both classes.


class Mom:
   var1 = "hey i am mom"

class Dad:
   var2 = "hey i am dad"

class child (Mom, Dad):
   var3 = "hey i am child"

momobj = Mom()
dadobj = Dad()
childobj  = child()

print childobj.var1
print childobj.var2
print childobj.var3


Output->
hey i am mom
hey i am dad
hey i am child


===============
Constructors
===============
Constructor is used to intialise the object data members of a class.

Construtor is called when object is created for class.
--------------------------------------------------------
syntax for the constructor
==========================
def __init__(self):

--------------------------------------------------------

class parentclass:

  def __init__(self):
    print "constructor is called"
    print "constructor is called when object is created"

pobj= parentclass()

Output->
constructor is called
constructor is called when object is created

===============
Import Modules
===============

python import the modules using the keyword called "import"

syntax:
-------

import <filename>

-> How to Access:

filename.<function>()


example :
---------

Just a sample file "testmodule.py"

testmodule.py
--------------
def testmod():
  print " I am in testmodule"

sample.py
----------
import testmodule   >>> Import the testmodule

testmodule.testmod()


Output->
I am in testmodule



===============
reload Modules
===============

"reload" is the keyword which can be reload the module.
Used if there are any modification done on the module.

example:
--------

Just a sample file "testmodule.py"

testmodule.py
--------------
def testmod():
  print " I am in testmodule"

sample.py
----------
import testmodule   >>> Import the testmodule

testmodule.testmod()

samplevariable= testmodule.testmod

samplevariable()

Note: The testmodule.testmod can be stored in the normal variable and can be called.


In case if we modify ->

testmodule.py
--------------
def testmod():
  print " I am in sample module"

then calling function of testmodule.testmod() print the old data as "I am in testmodule"

Then how to reflect the changes in the sample.py file.

Just you need to  use "reload(testmodule)"

----------------------------------
import testmodule   >>> Import the testmodule

testmodule.testmod()

reload(testmodule)

testmodule.testmod()


Output->
I am in testmodule
I am in sample module

====================
GETTING MODULE INFO
====================
==================================
How to get the module information
==================================

import math

dir(math) -> It gives information about the modules present
under the math.


['__doc__', 'acos', 'asin', 'fabs' ..... ]

help(math) -> Describe about each module.


The builtin function can be accessed using the "math.cos"

===================
WORKING with FILES
===================

python supports the file operations as similar to C language.


keywords: open, write, read, close.
---------

syntax for writing in to file:
------------------------------
fileObject= open('c:/test.txt', 'w')  // Here 'w' (write) or 'r' (read)

fileObject.write("Hey Muni i am here")

fileObject.close()


syntax for reading from the file:
---------------------------------

fileObject= open('c:/test.txt', 'r')  // Here 'w' (write) or 'r' (read)

fileObject.read()
fileObject.close()


Output ->
Hey Muni I am here

fileObject.read(3)

Output -> Hey
---------------------------------------
How to read and write line in files
---------------------------------------
using keyword line by line -> "readline() and writeline()"

-> To read all Lines
           - > readlines() and writelines()

--------
example:
--------

Write
-----

fobj= open('/home/test/test.txt', 'w')
fobj.write("muni sekhar reddy")
fobj.close()

write and read
--------------

fobj= open('/home/test/test.txt', 'w')
fobj.write("muni sekhar reddy")
fobj.close()


fobj= open('/home/test/test.txt', 'r')
print fobj.read()
fobj.close()

readline
--------
fobj= open('/home/test/test.txt', 'w')
fobj.write("muni sekhar reddy \n I love you \n")
fobj.close()

fobj= open('/home/test/test.txt', 'r')
print fobj.readline()
print fobj.readline()
fobj.close()


Output->

muni sekhar reddy
I love you

----------------------------------------------------
readlines   -> Reads all Lines and display as a list
----------
fobj= open('/home/test/test.txt', 'w')
fobj.write("muni sekhar reddy \n I love you \n")
fobj.close()

fobj= open('/home/test/test.txt', 'r')
print fobj.readlines()
fobj.close()

Output-> displays list.

['muni sekhar reddy \n', ' I love you \n']
-----------------------------
How to modify the file lines
-----------------------------

fobj= open('/home/test/test.txt', 'w')
fobj.write("muni sekhar reddy \n I love you \n")
fobj.close()

fobj= open('/home/test/test.txt', 'r')
listme= fobj.readlines()
fobj.close()

print listme

listme[1] = "sekhar reddy"

Now change the second line using..

fob= open('/home/test/test.txt', 'w')
fob.writelines(listme)
fob.close()

The list of lines are stored in the file. using writelines.


==============================================================================
Miscellanous and Advance concepts
==============================================================================

For loop with in a list notation  -> This is also called list comprehension.
=================================

syntax:

listme = [<variable> for i in range(10)]

This can be written as

example
-------
listme = []
listme= [ i for i in range(10,20)]
print listme


output->
[10,11,12,13,14,15,16,17,18,19]


The same can be represented as:->
-----------------------------------
listme=[]
for i in range(10,20):
 listme.append(i)
-----------------------------------

Other examples of list comprehension
--------------------

example:4
---------
data = ['3', '7.4', '8.2']
new_data = [float(n) for n in data]

Output->
[3.0, 7.4, 8.2]



example 5:
---------
myList = []
for i in range(10):
    if i%2 == 0:     # could be written as "if not i%2" more tersely
       myList.append(i)

The above condition can be comprehensed as

mylist = [i for i in range(10) if i%2==0]

Note:
-----
You can have "nested" list comrehensions, but they quickly become hard to comprehend
List comprehension will run faster than the equivalent for-loop,
and therefore is often a favorite with regular Python programmers who are concerned about efficiency


====================================================
How to start the Python program Using Main function
====================================================
--------
syntax 1:  main definition can be called as below.
--------

def main():
   print " I am in the Main function "

if __name__ == "__main__"
   main() // Call the main function here.

---------
syntax 2:
---------

def main(argv)
   print " I am in the main function with the arguments "

if __name__ == "__main__"
   main()  //Call the main function with arguments.

============================
Enumerate Keyword in Python
============================
enumerate keyword adds counter to the variable.
The enumerate() function adds a counter to an iterable.

example 1:

  for i in range(5)
    print i

Output -> 0, 1,2,3,4


example Using enumerate:
------------------------

  for count, i in enumerate(range(5))
    print count,i

Output -> count: 0,1,2,3,4  i => 0, 1,2,3,4

example Using List:
------------------------

By default enumeration starts from zero.


elementList = ['foo' , 'bar', 'baz']

for count, element in enumerate(elementlist)
  print count, element

Output-> rowindex, row value
0 foo
1 bar
2 baz

example Using List:
------------------------

elementList = ['foo' , 'bar', 'baz']

Enumeration starts from 43.


for count, element in enumerate(elementlist , 43)
  print count, element

Output->

43 foo
44 bar
45 baz


Example of List comprehension
=============================
t1=[1,2,'Hello',(1,2),999,1.23]
t2=[1,'Hello',(1,2),999]

t3=[]

for it1, e1 in enumerate(t1):
    for it2, e2 in enumerate(t2):
        if e1==e2:
            t3.append((it1,it2,e1))


(Or)

This can be optimised with list comprehension as

t3 = [(it1,it2, e1) for it1, e1 in enumerate(t1) for it2, e2 in enumerate(t2) if e1==e2]

========================
Iterables vs Generators
========================

Iterables

When you create a list, you can read its items one by one, and it’s called iteration:

>>> mylist = [1, 2, 3]
>>> for i in mylist:
...    print(i)
1
2
3

Mylist is an iterable. When you use a list comprehension, you create a list, and so an iterable:

>>> mylist = [x*x for x in range(3)]
>>> for i in mylist:
...    print(i)
0
1
4

Everything you can use “for… in…” on is an iterable: lists, strings, files…
These iterables are handy because you can read them as much as you wish,
but you store all the values in memory and it’s not always what you want when you have a lot of values.
Generators

Generators are iterators, but you can only iterate over them once.
It’s because they do not store all the values in memory, they generate the values on the fly:

>>> mygenerator = (x*x for x in range(3))
>>> for i in mygenerator:
...    print(i)
0
1
4

It is just the same except you used () instead of [].
BUT, you can not perform for i in mygenerator a second time since generators can only be used once:
they calculate 0, then forget about it and calculate 1, and end calculating 4, one by one.

=======
Yield
=======
Yield is a keyword that is used like return, except the function will return a generator.

>>> def createGenerator():
...    mylist = range(3)
...    for i in mylist:
...        yield i*i
...
>>> mygenerator = createGenerator() # create a generator
>>> print(mygenerator) # mygenerator is an object!
<generator object createGenerator at 0xb7555c34>
>>> for i in mygenerator:
...     print(i)
0
1
4

Here it’s a useless example, but it’s handy when you know your function
will return a huge set of values that you will only need to read once.

To master yield, you must understand that when you call the function,
the code you have written in the function body does not run.
The function only returns the generator object, this is a bit tricky :-)

=============================
Virtual functions in Python:
============================

By defualt all functions are virtual in python.

class parent:
  def hello(self):
     print " I am in class parent"

class child(parent):
  def hello(self):
     print " I am in child class"


def main():

  childobj = child()
  childobj.hello()

if __name__ == "__main__":
   main()


Output->

 I am in child class.


========================
Lists in the Dictionary
=========================


def main():
  list_sample = [1,2,3,4,5]

  print "the list len %d" % len(list_sample)

  dict_sample = {1: ['A', 'B'], 2:['D','E', 'F'], 3:['S', 'G', 'K']}

  dict_sample[2].append('Z')

  for items in dict_sample:
    flag=1
    for val in dict_sample[items]:
      if flag==1:
         print "if argv[%d] == val %s" % (items, val)
         flag+=1
      elif flag <len(dict_sample[items]):
           print "else if argv[%d] == val[%s]" % (items, val)
           flag+=1
      else:
           print "else  argv[%d]== %s" % (items, val)

                                                           
=============
Python Class
=============
-------------------------------------------------
Basic syntax of class : class base(object)

Constructor :  def __init__(self)

All methods should have one parameter:  self.

void display(self)
-------------------------------------------------
---------------
Class Example
---------------

class base(object):
  def __init__(self, name):
    self.name = name
    print "I am in the constructor"

  def display(self):
    print "The Name" +" " + self.name

def main():
  ob = base('muni')
  ob.display()

if __name__ == '__main__':
  main()

------------
Inheritance
------------

class base(object):
  def __init__(self, name):
    print " I am in constructor"
    self.name = name

  def display(self):
    print "I am in base class" +" " + self.name

class derived(base):
  def __init__(self, name):
    print " I am in derived"
    self.name = name

  def display(self):
    print "I am in derived class" + " "+ self.name

def main():
  ob = base("muni")
  ob.display()

  der = derived("sekhar")
  der.display()

if __name__=='__main__':
  main()


Note: Base class constructors can't be inherited in the derived class.

Output:
I am in constructor
I am in base class muni
I am in constructor
I am in derived class sekhar

-----------------------
Class Scope Variables:
-----------------------
The Variables declared outside of the methods is accessible to every object.
Same memory is shared across all the objects (Like static variable in C++)

class base(object):
 name = "Nipom"

def main():

  ob = base()
  base.name = "Reddy"
  ob1 = base()
  print ob1.name
  print ob.name
if __name__=='__main__':
  main()

Note:  The Class scope variable is modified by the "class name.<Variable> "
-----
If it is modified by the object, it will be reflected only to the object.

Output:

 Reddy
 Reddy
--------------
Example 3:
==============

class Dog:

    tricks = []             # mistaken use of a class variable

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')

-----------
Example 4
-----------

class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']
>>> e.add_trick('play dead')
>>> d.tricks                # unexpectedly shared by all dogs
['roll over', 'play dead']