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

Answer 1

Using string substitutions:

name = "Joe"
age = 12
print "My name is %s, I am %s" % (name, age)

When I'm not programming in python, that simple use is what I miss most.

Answer 2

Another thing you cannot start early enough is probably testing. Here especially doctests are a great way of testing your code by explaining it at the same time.

doctests are simple text file containing an interactive interpreter session plus text like this:

Let's instantiate our class::

>>> a=Something(text="yes")
>>> a.text
yes

Now call this method and check the results::

>>> a.canify()
>>> a.text
yes, I can

If e.g. a.text returns something different the test will fail.

doctests can be inside docstrings or standalone textfiles and are executed by using the doctests module. Of course the more known unit tests are also available.

Answer 3

An important idiom in Python is docstrings.

Every object has a __doc__ attribute that can be used to get help on that object. You can set the __doc__ attribute on modules, classes, methods, and functions like this:

# this is m.py
""" module docstring """

class c:
    """class docstring"""
    def m(self):
        """method docstring"""
        pass

def f(a):
    """function f docstring"""
    return

Now, when you type help(m), help(m.f) etc. it will print the docstring as a help message.

Because it's just part of normal object introspection this can be used by documention generating systems like epydoc or used for testing purposes by unittest.

It can also be put to more unconventional (i.e. non-idiomatic) uses such as grammars in Dparser.

Where it gets even more interesting to me is that, even though doc is a read-only attribute on most objects, you can use them anywhere like this:

x = 5
""" pseudo docstring for x """

and documentation tools like epydoc can pick them up and format them properly (as opposed to a normal comment which stays inside the code formatting.

Answer 4

Decorators get my vote. Where else can you write something like:

def trace(num_args=0):
  def wrapper(func):
    def new_f(*a,**k):
      print_args = ''
      if num_args > 0:
        print_args = str.join(',', [str(x) for x in a[0:num_args]])
      print('entering %s(%s)' %(f.__name__,print_args))
      rc = f(*a,**k)
      if rc is not None:
        print('exiting %s(%s)=%s' %(f.__name__,str(rc)))
      else:
        print('exiting %s(%s)' %(f.__name__))
      return rc
    return new_f
  return wrapper

@trace(1)
def factorial(n):
  if n < 2:
    return 1
  return n * factorial(n-1)
factorial(5)

and get output like:

entering factorial(5)
entering factorial(4)
entering factorial(3)
entering factorial(2)
entering factorial(1)
entering factorial(0)
exiting factorial(0)=1
exiting factorial(1)=1
exiting factorial(2)=2
exiting factorial(3)=6
exiting factorial(4)=24
exiting factorial(5)=120

Answer 5

Here's one that can help. What's the difference between:

[ foo(x) for x in range(0, 5) ][0]

and

( foo(x) for x in range(0, 5) ).next()

answer: in the second example, foo is called only once. This may be important if foo has a side effect, or if the iterable being used to construct the list is large.

Answer 6

Personally, I really like Python syntax defining code blocks by using indentation, and not by the words "BEGIN" and "END" (as in Microsoft's Basic and Visual Basic - I don't like these) or by using left- and right-braces (as in C, C++, Java, Perl - I like these).

This really surprised me because, although indentation has always been very important to me, I didn't make to much "noise" about it - I lived with it, and it is considered a skill to be able to read other peoples, "spaghetti" code. Furthermore, I never heard another programmer suggest making indentation a part of a language. Until Python! I only wish I had realized this idea first.

To me, it is as if Python's syntax forces you to write good, readable code.

Okay, I'll get off my soap-box. ;-)