The hash function comments in Objects/dictobject.c no longer match the implementation:

"""
/*                                                                                                                                
Major subtleties ahead:  Most hash schemes depend on having a "good" hash                                                         
function, in the sense of simulating randomness.  Python doesn't:  its most                                                       
important hash functions (for strings and ints) are very regular in common                                                        
cases:                                                                                                                            
                                                                                                                                  
  >>> map(hash, (0, 1, 2, 3))                                                                                                     
  [0, 1, 2, 3]                                                                                                                    
  >>> map(hash, ("namea", "nameb", "namec", "named"))                                                                             
  [-1658398457, -1658398460, -1658398459, -1658398462]                                                                            
  >>>                                                                                                                             
                                                                                                                                  
This isn't necessarily bad!  To the contrary, in a table of size 2**i, taking                                                     
the low-order i bits as the initial table index is extremely fast, and there                                                      
are no collisions at all for dicts indexed by a contiguous range of ints.                                                         
The same is approximately true when keys are "consecutive" strings.  So this                                                      
gives better-than-random behavior in common cases, and that's very desirable. 
"""

Christian, I assigned to you because I thought you had done the SIPhash work that invalidated these comments.   Do you know who the right person is?

Submitting patch which tries to cover mentioned change. I request Core-developers to verify the approach I took for fixing this change. Thanks!

Completely remove all reference to strings as it is normally completely wrong.  In three runs of
   list(map(hash, ("namea", "nameb", "namec", "named")))
I get
[-7801965690653662103, -712276634514874737, 4394438508544812081, -6975951345912708912]
[-1171799829, 419385606, 1995488749, 1433346153]
[551304887, -285234584, -553876274, -279423320]

Rewrite for ints only.

I am willing to apply, but cannot patch 3.4, so Raymond, if you want that, you will have to do it.

Improving last with with following points:
1. Removing string related examples
2. Updating int example with more readable way (According to me).

Reviewer review the patch file named "issue20674_patch_v3.diff"

I've left comments on rietveld. Not sure if everyone's seeing them.

Agreeing with "SilentGhost". Demonstrating `hash()` example for type int using list comprehension. Review  issue20674_patch_v5.diff Thanks!

Oops, wrong number in the commit message.  Thanks for the patch, Jaysinh. 

New changeset 74109d87283f by R David Murray in branch '3.5':
#20647: Update dictobject.c comments to account for randomized string hashes.
https://hg.python.org/cpython/rev/74109d87283f

New changeset 31cdf23da19d by R David Murray in branch 'default':
Merge: #20647: Update dictobject.c comments to account for randomized string hashes.