What do you wish you'd known about when you started learning Python? [closed]

Answer 1

List comprehensions, if you're coming to Python fresh (not from an earlier version).

Answer 2

Maybe a touch more advanced, but I wish I'd known that you don't use threads to take advantage of multiple cores in (C)python. You use the multiprocessing library.

Answer 3

List comprehension (makes a list cleanly):

[x for x in y if x > z]

Generator expansion (same as list comprehension but doesn't evaluate until it is used):

(x for x in y if x > z)

Answer 4

If you learn from a good book, it will not only teach you the language, it will teach you the common idioms. The idioms are valuable.

For example, here is the standard idiom for initializing a class instance with a list:

class Foo(object):
    def __init__(self, lst=None):
        if lst is None:
            self.lst = []
        else:
            self.lst = lst

If you learn this as an idiom from a book, you don't have to learn the hard way why this is the standard idiom. @S.Lott already explained this one: if you try to make the default initializer be an empty list, the empty list gets evaluated just once (at compile time) and every default-initialized instance of your class gets the same list instance, which was not what was intended here.

Some idioms protect you from non-intended effects; some help you get best performance out of the language; and some are just small points of style, which help other Python fans understand your code better.

I learned out of the book Learning Python and it introduced me to some of the idioms.

Here's a web page devoted to idioms: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html

P.S. Python code that follows the best-practice Python idioms often is called "Pythonic" code.

Answer 5

Dropping into interactive mode in IPython

from IPython.Shell import IPShellEmbed
ipshell = IPShellEmbed()
ipshell()

Answer 6

I learned Python back before the 1.5.2 release, so the things that were key for me back then may not be the key things today.

That being said, a crucial thing that took me a little bit to realize, but I now consider crucial: much functionality that other languages would make intrinsic is actually made available by the standard library and the built-ins.

The language itself is small and simple, but until you're familiar with the built-ins and the "core parts" of the standard library (e.g., nowadays, sys, itertools, collections, copy, ...), you'll be reinventing the wheel over and over. So, the more time you invest in getting familiar with those parts, the smoother your progress will be. Every time you have a task you want to do, that doesn't seem to be directly supported by the language, first ask yourself: what built-ins or modules in the standard library will make the task much simpler, or even do it all for me? Sometimes there won't be any, but more often than not you'll find excellent solutions by proceeding with this mindset.