Python

Dictionary in python :

Dictionary is basically key value binding .
As String is enclosed within " "
As List is enclosed within    [  ]
As tuple is enclosed within  (  )

Here dictionary ,it is enclosed within  {  }

In String , list tuple , also we have this same idea ,,, but there key is always an integer ... so we call it index

So  Stringname or listname or tuplename [1] means , item at index 1

Dictionary gives scope for having having even non integer keys

To declare a Dictionary :   d = { }

>>d['a'] = 'alpha'
>>d['o']='omega'
>>d['g']='gamma'

this is the way to assign value in a dictionary .

Now,  to retrieve a value in String or list or tuple , what will u do ,?  name[index]

similarly here  >>d['a']  displays   'alpha'

The advantage of having key and corresponding value storage is that , it is fast at retrieval using key ,,
this is the advantage of hashtable

But don't know why it is faster in this way .........
 
If you give d['x'] , it flings an error , as the key x is not there in dictionary d .

So , what can be the way to bypass , this even if the key is not there , but still , not flag an error ,,
this can be used in future to check if a key exists in a dictionary ..

Ya, we have a 2 solutions

1) d.get['x]  returns value null if key x is not found and returns the actual corresponding value if the key exists

>>d.get['a']  returns  'alpha'
2) As , we do in lists is ,a =[1,2,3]
to find if 2 is a value inside it ,, we say  2 in a   , returns true if 2 value is there  (note that here we r searching by value , so this time is longer )
Here also same thing

'a' in d  returns true if key 'a' exists , false if it doesn't exist

To see the list of keys at once in a dictionary 

d.keys()

To see the list of values at once in a dictionary

d.values()

To get values ,,, just loop over

for k in d.keys() :
    print d[k]

to have it ordered

for k in sorted(d.keys()):
   print d[k]


To see list of key value pair .

d.items() ...............returns

[('a','alpha') , ('o','omega'),('g','gamma')]

looping over  ? ya , easy
for tuple in d.items() :
    print tuple

File operation in Python : 

f = open(filename , 'r')

the second argument indicates , whether we r opening file for reading or 'w' denotes 'writing .. similary we have 'rU'

f is here the file handler ,,,  by this line we just open the file and give it to f  ,, from f we can read it
now we can iterate each line ,,as soon as it sees a new line in f  ( which is a reflection of file filename which is open ), it stops ,reading ,
like this we iterate over every line

for line in f:
    print line

prints each line but with double line space between

this is because print itself has a new line and the new line in file adds to it ,,
so to eliminate it replace print statement by
print line,

the trailing comma removes this problem as it removes the new line in the print

finally , we have to close the open file ,,as a open file unnecessarily draws memory

f.close()

if u omit this line , when the process ends the file is closed automatical
but in case of softwares which r continuously running , the process also runs , so here if we don't close, it remains open the whole period of time , when software runs ,and that too unnecessarily
what is the advantage of having this concept of reading line by line ? why not read at once

when we read , big files say 90 Gb ,,  reading at once gives problem of locking heavy memory

when we read line by line only a small part of memory is locked for its work ,

f.readlines()

gives o/p as a list of lines

['line1' ,'line2','line3'...]

it even prints it in the same way as shown above

f.read()

reads entire file into a single string

so has same view as we open a file in editor in gui