I have no good suggestion of ressources, but I'd say an important point if you want to write pythonic code is the use of iterables/iterators/generators/etc.
I mean, if you have to compute the product of the elements in a list, avoid
Code:
accum = 1
for i in range(len(L)) :
accum *= L[i]
and prefer
Code:
accum = 1
for elem in L :
accum *= elem
It may be a detail, but it's probably one of the most obvious things that shows you haven't used Python much. Even more so when Python has a strong emphasis on lists (which are actually resizable arrays that can handle different types) and iterables in general.
If you need both the elements and the index, use
Code:
for i, elem in enumerate(L) :
If you need to iterate over several lists at the same time, use
Code:
for elem1, elem2 in zip(L1, L2) :
etc.
When you're fine with the base of the language, look into generator functions (and itertools, too). Take some time to look into dicts.
Usually, "Pythonic" means "easily understandable", since it was partly designed for readability. Think about the types that will work best, and how you can write the code to make it readable, and you'll probably get "pythonic" constructs most of the time.
After that, it's mostly a matter of time to learn all the tricks you can use. Reading code can be helpful. StackOverflow has been useful to me to discover some interesting constructs.
Try not to reinvent the wheel, there's so many modules available that a lot of things you don't have to write yourself. I won't suggest you reading the whole "standard set" of modules, but at least look into what's available, it's probably deemed unpythonic of not using one of the standard modules
Also, not strictly "Pythonic", but Python is awful to warn you about possible bugs (since you don't have a compilation, and it use dynamic typing without any nice way to check the type of an argument, because it's actually unpythonic to do so). So Python is a language that HEAVILY relies on testing.
You should probably get used to design a LOT of unit tests for all your functions if you intent to create large code.
I'm really not that fond of some parts of that PEP (but I think we discussed it already), and the main thing I remember is readability is over consistency or PEP-8...
Also, I wonder how much "pythonic" refers to the basic formatting/spacing/indentations...
I'm not really sure how useful it is, but I'm convinced it's a nice thing to have. If you can contribute to an open-source project, it's probably nice too.