What are the important language features (idioms) of Python to learn early on [duplicate]

Answer 1

Python is a language that can be described as:

"rules you can fit in the palm of your hand with a huge bag of hooks".

Nearly everything in python follows the same simple standards. Everything is accessible, changeable, and tweakable. There are very few language level elements.

Take for example, the len(data) builtin function. len(data) works by simply checking for a data.__len__() method, and then calls it and returns the value. That way, len() can work on any object that implements a __len__() method.

---

Start by learning about the types and basic syntax:

1. Dynamic Strongly Typed Languages
2. bool, int, float, string, list, tuple, dict, set
3. statements, indenting, "everything is an object"
4. basic function definitions

Then move on to learning about how python works:

1. imports and modules (really simple)
2. the python path (sys.path)
3. the dir() function
4. __builtins__

Once you have an understanding of how to fit pieces together, go back and cover some of the more advanced language features:

1. iterators
2. overrides like __len__ (there are tons of these)
3. list comprehensions and generators
4. classes and objects (again, really simple once you know a couple rules)
5. python inheritance rules

And once you have a comfort level with these items (with a focus on what makes them pythonic), look at more specific items:

1. Threading in python (note the Global Interpreter Lock)
2. context managers
3. database access
4. file IO
5. sockets
6. etc...

---

And never forget The Zen of Python (by Tim Peters)

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Answer 2

From a more advanced viewpoint, understanding how dictionaries are used internally by Python. Classes, functions, modules, references are all just properties on a dictionary. Once this is understood it's easy to understand how to monkey patch and use the powerful __gettattr__, __setattr__, and __call__ methods.

Answer 3

I think that tutorials online and books only talk about doing things, not doing things in the best way. Along with the python syntax i think that speed in some cases is important.

Python provides a way to benchmark functions, actually two!!

One way is to use the profile module, like so:

import profile

def foo(x, y, z):
    return x**y % z # Just an example.

profile.run('foo(5, 6, 3)')

Another way to do this is to use the timeit module, like this:

import timeit

def foo(x, y, z):
    return x**y % z # Can also be 'pow(x, y, z)' which is way faster.

timeit.timeit('foo(5, 6, 3)', 'from __main__ import *', number = 100) 
# timeit.timeit(testcode, setupcode, number = number_of_iterations)

Answer 4

This page covers all the major python idioms: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html

Answer 5

Everything connected to list usage.
Comprehensions, generators, etc.

Answer 6

Two things that struck me as especially Pythonic were dynamic typing and the various flavors of lists used in Python, particularly tuples.

Python's list obsession could be said to be LISP-y, but it's got its own unique flavor. A line like:

return HandEvaluator.StraightFlush, (PokerCard.longFaces[index + 4], 
  PokerCard.longSuits[flushSuit]), []

or even

return False, False, False

just looks like Python and nothing else. (Technically, you'd see the latter in Lua as well, but Lua is pretty Pythonic in general.)