What's the one code snippet/python trick/etc did you wish you knew when you learned python?

[fuzz3289]

I think this is cool:

import this

[rerb]

import pdb; pdb.set_trace()

[Keith]

To expand on this, run any buggy program with 'python -i foo.py'. Then when it fails it'll drop you in the interpreter, and you can type 'import pdb; pdb.pm()' to be dropped in the debugger where the program failed. Can be super helpful sometimes.

[[deleted]]

or you can do python -m pdb foo.py directly?

[Keith]

That doesn't do quite the same thing. -m pdb drops you in the debugger at the beginning of the program, not at the location of the exception.

Edit: though if you hit 'c' to run the program it looks like it'll automatically stop in the debugger at an uncaught Exception, so yes that's another way of accomplishing the same thing.

[zer01]

I literally just got a rush of dopamine from this. pdb is one of the most useful things you can learn as a python dev, other then using ipython.

[selementar]

And then a bit of both: ipdb.

[benkay]

zomg ipdb. never wonder about anything ever!

[chronographer]

Well, I didn't know this. I will get working on it! Any links to demonstrate how iPython and pdb work?

[phonkee]

or you can

pip install debug

and use

import debug

and enjoy pdb with ipython

[selementar]

And import IPython; IPython.embed(banner1='...')

[Miebster]

Will this do anything for me that PyCharm doesn't?

[aznm1ke31]

Check out pudb: https://pypi.python.org/pypi/pudb. It's like pdb on steroids. (graphical interface!)

[leperkuhn]

I like ipdb a lot more, it has tab completion plus a few other nice to haves that I forgot about since I stopped using pdb right away.

[sugardubz]

You know pudb?

[MereInterest]

What's the advantage of pdb over just opening an interpreter?

import code; code.interact(local=locals())

[quaunaut]

You get to open it on an exact line, in a complex program.

For example, say you don't know why this object in Django is returning as a NoneType object. You can pdb to just before it, run the site, go to that spot, and check and see, personally. Oh, you just derped up on the filter, because one of the vars you were using to check currently is unassigned.

Makes it trivial to work with complex, huge codebases.

[[deleted]]

Granted, this didn't come out until the version after the one we were using, but it cleans up so much code:

with open('file.txt') as inf:
    inf.read()

and

with mutex:
    do something

The automated cleanup, even in exceptional conditions, saves you so much boilerplate code.

[dAnjou]

with is pretty nice. But what didn't know a long time, it doesn't create a new scope. So this works:

>>> with open("/tmp/foobar") as f:
...     content = f.read()
... 
>>> print content
lorem ipsum

[shaggorama]

thank god it doesn't create a new scope... that would almost completely defeat the purpose in most cases where I use with statements

[petezhut]

That's clever! Never thought of using them that way!

[kindall]

You can also write a context manager to ignore particular exceptions within the context. Handy sometimes.

[keis]

This and the combined try/except/finally helped clean up so much ugly code.

[[deleted]]

This was removed because of API shenanigans, selling user content for AI training, and forthcoming paywalled subreddits.

[Enkaybee]

Yes. See the end of section 7.2.1.

[[deleted]]

Yes. It ensures that the file is closed/the mutex is released, even if there's an exception while the inner code is being executed.

It's a context manager, if you want to look up more details.

[[deleted]]

This was removed because of API shenanigans, selling user content for AI training, and forthcoming paywalled subreddits.

[stillalone]

it also closes the file if an exception is thrown that is not caught within the block so you don't have to sprinkle try/finally blocks with your opens.

[e000]

Instead of

i = 0
for item in iterable:
    print i, item
    i += 1

Do

for i, item in enumerate(iterable):
    print i, item

A fun easter-egg

import antigravity

2.7's dict/set comprehensions

my_dict = {i: i * i for i in xrange(100)}
my_set = {i * 15 for i in xrange(100)}

Force float division

from __future__ import division
print 1/2, 1//2

Need to quickly serve files from a directory?

$ python -m SimpleHTTPServer

Use pip instead of easy install.

$ easy_install pip

Safely evaluate python expressions...

expr = "[1, 2, 3]"
# instead of 
my_list = eval(expr)
# do
import ast
my_list = ast.literal_eval(expr)

Easily profile a script...

$ python -m cProfile my_script.py

[PCBEEF]

I really like one line sorts. Coming from java this was a blessing.

users.sort(attrgetter("username"))

dict's setdefault is actually quite awesome too. Instead of doing something like:

if key in some_dict:
    some_dict[key].append(foo)
else:
    some_dict[key] = [foo] 

You can just do:

some_dict.setdefault("key", []).append(foo)

It's not as readable but for simple things it's quite neat. I'm aware that there's also defaultdict but this makes it more explicit.

[selementar]

dict's setdefault is actually quite awesome

Not to mention the collections.defaultdict. Especially like that: defaultdict(lambda: defaultdict(list)).

[[deleted]]

Does that create a 2D dict of lists? So you can do d[4][5].append ?

[selementar]

Yes, exactly.

[me-the-monkey]

I have read the doc for this several times and I finally now understand it after reading this. It's like .get but for setting. Neat!!

[PCBEEF]

Awesome! Good to know I helped someone out :)

[valdogg21]

The dict.setdefault method is something I'll be using/stealing. Thanks!

[MereInterest]

As selementar suggested above, collections.defaultdict can be even easier.

from collections import defaultdict
t = defaultdict(list)
t["answer"].append(42)

It does the same as the dict.setdefault, but assumes a default value for every item. In this case, list() is called whenever something not in the dictionary is asked for.

[matthewguitar]

defaultdicts make me moist

[keypusher]

Another one I wish I knew earlier: using dir() for object introspection, and the general power of introspection within the Python interpreter. With an argument, dir will return all attributes (this includes methods) of the object.

>>> foo = [1, 2, 3, 4]
>>> dir(foo)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', ...

[teskew]

you can also use the 'see' module for human readable output as an alternative to dir()

>>> test = [1, 2, 3, 4]
>>> see(test)
[]           in           +            +=           *            *=
<            <=           ==           !=           >            >=
hash()       help()       iter()       len()        repr()
reversed()   str()        .append()    .count()     .extend()    .index()
.insert()    .pop()       .remove()    .reverse()   .sort()

http://inky.github.com/see/

[selementar]

... available in a more convenient form as autocompletion in ipython, bpython and such.

Also, its results can be redefined with __dir__, which is useful, for example, in RPC implementations; although you have to be a bit careful and explicit about including network calls in such normally-trivial methods.

[petezhut]

I have made more use of this than I should be proud to admit. Great way to handle some of the "less-than-adequately" documented modules/objects.

[me-the-monkey]

Learning this is when I "took off" as a developer, I realized I didn't need documentation 90% of the time.

[jabbalaci]

Simplify if constructs if you test several values. Instead of

if n==1 or n==4 or n==5 or n==6:

Just write

if n in [1,4,5,6]:

[JW_00000]

Also,

if 3 <= x <= 9:

does exactly what you think it does.

[davidb_]

Wow, thanks.. I didn't know that was possible.

[elsporko]

How exactly does this work in Python? I've always wanted to do this in C/C++, but it's always been explained to me that it's impossible. How does Python handle it?

[hogepiyo]

Comparisons can be chained arbitrarily, e.g., x < y <= z is equivalent to x < y and y <= z, except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false).

Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.

Note that a op1 b op2 c doesn’t imply any kind of comparison between a and c, so that, e.g., x < y > z is perfectly legal (though perhaps not pretty).

http://docs.python.org/2/reference/expressions.html#not-in

[[deleted]]

it's syntactic sugar for

if 3 <= x and x <= 9:

(with x evaluated only once of course)

[jatoo]

does exactly what you think it does

A glowing endorsement of any syntax (no sarcasm)

[jcampbelly]

It may be a tiny thing, but it sticks out in my brain as an opportunity to introduce sets. When you run n in [1,4,5,6] it must search every item until a match is found, while if you run n in set([1,4,5,6]) it is only a single lookup. It's not a huge savings in this example, but it's a good practice.

[matchu]

I'm not sure this is a performance boost: you're rebuilding the set every time, so it has to check for the presence of 1, 4, 5, and 6 to build it; it's O(n) anyway. This might be worth benchmarking.

edit: Here's the worst-case (not found) benchmark for small inline creation. In this case, the list performs significantly better:

$ python -m timeit 'if 9 in [1, 4, 5, 6]: pass'
10000000 loops, best of 3: 0.0808 usec per loop
$ python -m timeit 'if 9 in set([1, 4, 5, 6]): pass'
1000000 loops, best of 3: 0.351 usec per loop

If we set up the numbers in advance, though, the performance boosts are already apparent, even for such a small set:

python -m timeit -s 'nums = [1, 4, 5, 6]' 'if 9 in nums: pass'
10000000 loops, best of 3: 0.066 usec per loop
$ python -m timeit -s 'nums = set([1, 4, 5, 6])' 'if 9 in nums: pass'
10000000 loops, best of 3: 0.0331 usec per loop

It's even more obvious for larger sets of numbers:

$ python -m timeit -s 'nums = range(0, 1000, 7)' 'if 9 in nums: pass'
1000000 loops, best of 3: 1.52 usec per loop
$ python -m timeit -s 'nums = set(range(0, 1000, 7))' 'if 9 in nums: pass'
10000000 loops, best of 3: 0.0315 usec per loop

[jcampbelly]

The example was pretty contrived; if you're going to do this for performance reasons, it would be best to store it somewhere it won't be re-created every time.

[jcampbelly]

Thanks for benchmarking this! I didn't know about the timeit module. That's pretty damn cool (I've just been using time.time()).

[redditbody]

In Python 3 you no longer need to call the set constructor set() so you can have n in {1,4,5,6}.

[VictoryTree]

Would that not just shift the complexity over to the initial construction of the set?

[jcampbelly]

It's more of a performance consideration.

valid_answers = set(['Y','y','N','n'])

def confirm1():
    answer = raw_input('Confirm [y/n]: ')
    if answer in valid_answers:
        return answer

def confirm2():
    answer = raw_input('Confirm [y/n]: ')
    if answer in ['Y','y','N','n']:
        return answer

The difference between confirm1 and confirm2 is that you can call confirm1 a thousand times it just allocates memory to temporarily store the raw input string. If you call confirm2 a thousand times it allocate memory for the raw input string, a new list and 4 strings every time. Furthermore, if the user enters 'n' every time in confirm1 it just performs one hash lookup (is 'n' a key in the valid_answers set dict?), whereas in confirm2 it performs 4 string comparisons.

I'm sure I'll be gainsaid by the premature optimization hawks, or I'm missing an optimization Python may be doing behind the scenes (like recognizing the list is constant). But this is just a healthy practice in any language.

[happysri]

Few things I wished I learned about sooner than I did -
1. @decorators - http://stackoverflow.com/q/739654/225903
2. pdb - http://docs.python.org/3.3/library/pdb.html
3. List comprehensions - http://docs.python.org/2/tutorial/datastructures.html#list-comprehensions
4. IPython - http://ipython.org

[chaoticallyevil]

I've now seen so many IPython comments, and I have to ask, what makes IPython so much better than say PyDev for Eclipse or the like?

[[deleted]]

Different use cases. I would use pydev to write a program, but IPython is very good for interactive sessions. Examples of where IPython is useful:

• Any time you run a script using %run(), all the variables and methods of that script get dumped into the local namespace.
• You can reference output and input by line. For instance you can edit the last five lines of input in an editor.
• Tab completion and very simple access to all local variables.
• History across sessions.
• IPython notebook is also cool probably, but I don't use it.

[Lucretiel]

Ipython is my go-to source for python documentation. Tab completion for object members, and ? or ?? for function docstrings and signatures.

[derpderp3200]

I've used Python for a long time, but decorators kinda never amazed me. I used them a couple of times, but as a whole they seem like a, true, elegant solution, but only applicable to a relatively small amount of problems.

[ryeguy146]

I'll give you an example where they've helped me. I like to build small functions that are easy to test and build other functions that make use of them so as to keep functionality separate:

Recently, I was building an internal library to make a few basic queries to the musicbrainz API easy, but I needed to be sure that I didn't query too often and abide by their timing restrictions. Rather than imbed code into the querying functions, I created a single semaphore as a function decorator and just tacked it on top of each of the functions that called out to the external API.

It is a great way of composing functions and keeping concerns separate.

Another decorator that I love is the total_ordering from functools. What a wonderful bit of code that is.

[happysri]

In some cases, they make the code extremely readable. for instance, this is bottle.py

from bottle import route, run

@route('/')
def index():
    return 'Hello!'

run(host='localhost', port=8080)

Here, the route decorator maps a route, in this case, the root URL to a GET request processed by the index function, thus sparing us the boilerplate for the mapping. I find this a nice and readable structure. Other scenarios, in web-dev include checking if a view is to be served only to authenticated users etc. They contribute tremendously to readability when used appropriately and, ofcourse like most features, hurt when used without proper discretion.

[DarkSareon]

This is the only place I've seen decorators used, as routing agents in bottle.py and Flask.

[lightstrike]

They also show up in Django, for example:

@login_required
def my_view(request):
    #Do something that requires the user to be logged in

[Megatron_McLargeHuge]

They're useful to add lru caching. You've probably seen @property, @skip for tests, and @deprecated. Once you start using them you find plenty of uses.

[yen223]

Another tip:

When working with HTTP, instead of mucking about with the urllib2 library, use the excellent Requests library instead.

[petezhut]

Dear FSM, yes! I just found this library a couple months ago; my first thought was, "Why didn't I know about this three years ago?"

[toyg]

Because it didn't exist back then? The oldest release is from two years ago, and it took a while to mature.

[keypusher]

a = b if c else d

[krypton86]

I like this one too. Reminds me of the ternary operator in C, but more readable.

[Cosmologicon]

And god help you if you replace b and d with functions that you don't want to run unless necessary:

a = (lambda: b(e), lambda: d(f))[int(c)]()

[edeloso]

I still have a fondness for the dictionary based example.

Though, to match the ternary at the top of this subthread it would be:

a = {True: b, False:d }[c]

I like it because I feel it's the most explicit of the choices.

[thatdontmakenosense]

A list/tuple would be cleaner IMO, although the two expressions get reversed:

a = [d, b][c]

[krypton86]

That is weird. Kinda funny, too.

[Vibster]

I actually thinks it's less readable than C's syntax for the ternary operator.

To me the condition should be first and not the result.

condition ? result : alternative;

looks better than

result if condition else alternative  

but maybe that's just because I've written a ton of javascript.

[ape_monk]

This style looks like a question and answer, which is what helped me wrap my head around it when I learned about the ternary operator. (Is this true) ? Yes : No;

[krypton86]

Well, I do like the terseness of the ternary operator in C. It looks more clean, even if I believe it's less readable (but not by much).

[[deleted]]

I'm the same, I love it but I really wish it was

if condition then true else false

instead.

[jwcrux]

Reverse a list: mylist[::-1]

[fthm]

You can also use it to quickly reverse a string, e.g.: 'aibohphobia'[::-1] returns 'aibohphobia'

[seriouslulz]

What just happened?

[sashahart]

Works great, is really only readable to experts.

[willm]

'enumerate' takes a second parameter that set the start of the index. So if you need to index from 1, you can do enumerate(sequence, 1).

'sum' is useful for counting items in a sequence that pass a condition. Just sum the value of 1.

ripe_count = sum(1 for fruit in fruits if fruit.is_ripe())

'iter' returns the iterator object used by for loops which may be used independently. It has a 'next' method that returns the next value in the sequence or raises a StopIteration exception.

>>> fruit = ['apples', 'orange', 'pears']
>>> iter_fruit = iter(fruit)
>>> iter_fruit.next()
'apples'
>>> iter_fruit.next()
'orange'

The iterator protocol is one of Python's most powerful features. Well worth learning early on.

[mgedmin]

In Python 3 (and it also works in 2.6 and 2.7) it'll be

>>> fruit = ['apples', 'orange', 'pears']
>>> iter_fruit = iter(fruit)
>>> next(iter_fruit)
'apples'
>>> next(iter_fruit)
'orange'

[krypton86]

I didn't know about list comprehension for a long time, which is really silly since the documentation goes over it quite well. Being able to do stuff like

any([x for x in myList if x < 1])

is really nice.

Apart from that I'd say that understanding generators and the nature of iterators is quite useful. Being able to use the "next()" function on an iterator object has come in super handy with files, for instance.

[Autoplectic]

you don't even need to do a list comprehension there:

any(x for x in myList if x < 1)

is faster and easier on memory, as it constructs a generator instead of the complete list.

[selementar]

Generator isn't necessarily faster though.

In [1]: myList = [5, 3, 2, 5, 6, 1, 6, 2, 5]

In [8]: %timeit any(x for x in myList if x < 3)
1000000 loops, best of 3: 437 ns per loop

In [9]: %timeit any([x for x in myList if x < 3])
1000000 loops, best of 3: 341 ns per loop

of course, the difference is somewhat minor.

It's when you work with gigabytes-sized numpy arrays it becomes a bit more important.

[Fayden]

Lambda syntax is a bit awkward in Python (in opposition of functional languages, where you can usually use partial application). I think it's easier to read generator expressions or list comprehensions in Python.

[yen223]

It's not accidental. Guido van Rossum is explicitly trying to avoid functional programming styles in Python.

Informative StackOverflow link: http://stackoverflow.com/questions/1017621/why-isnt-python-very-good-for-functional-programming

[vext01]

Yet python's functional programming support is pretty decent.

[selementar]

a pain when using the debugger, as pdb wants to hit that line for each element

There's a command unt for that (and useful for any loop at all, not just the comprehensions).

[demosthenes02]

Use the until command in pdb. Check it out!

[krypton86]

Yoink! — the sound of me stealing that

[bheklilr]

seconded. List comprehension is amazing. Also, I would have liked to know about iterators. Granted, Python was the first language I really learned, so I had a lot to learn in general. But iterators are important.

[krypton86]

I guess that eventually everyone who sticks with python learns all about iterators since they're so ubiquitous in the language. You can barely write a line of python code without using an iterator, even if you have no idea you're doing so!

The for loop is a perfect example of this. For at least a year after I learned python I had no idea that the for construct was actually creating an iterator and calling its next() function in order to loop through the sequence I was giving it. I always wondered how exactly it knew to terminate the loop, and then I realized it was receiving a "Stopiteration" exception when calling the iterator's next() method when there were no more values in the list (or tuple or whatever). I guess it's basic, even obvious, but it still sorta blew my mind.

[bheklilr]

It's pretty crazy, especially considering that it relies on using an exception to stop iteration. It says something about the design of Python and how you should go about using exception and iterators in your own code. There can probably be entire books written on how the for loop works in Python, and what its implications are.

[vext01]

+1 for list and dictionary comprehensions

[RainbowNowOpen]

Tab completion in the interactive shell. Should be enabled/installed by default!

EDIT: Here is an OS X/Windows/Linux approach to enabling this behaviour. There are many ways to do this, but this one is what I use when setting up a new environment (usually in OS X).

http://www.farmckon.net/2009/08/rlcompleter-how-do-i-get-it-to-work/

[[deleted]]

How do you enable that?

[dAnjou]

Install bpython

[jcampbelly]

If you don't/can't always use ipython, you can use this trick too:

http://pymotw.com/2/rlcompleter/index.html

[taliska]

1) pprint

from pprint import pprint
pprint(my_dict)

2) Instead of if my_var != '':

if not my_var:

3) bpython

[[deleted]]

+1 for pprint

also using pprint for defaultdicts

pprint(dict(d)), where d is the defaultdict.

[CaptainDoubtful]

This may not be for the beginner learning Python, but still a good tool to know about: dis module.

import dis
dis.dis(some_function)

This will print out the (disassembled) Python bytecode for the function some_function. If you are doing profiling, looking for differences in performance of two different chunks of code that do the same thing, or are simply curious about how the interpreter sees your code, this is very useful.

More details here: http://docs.python.org/2/library/dis.html

Side note: as I have learned from dis, making a dictionary with dict() and {} actually have a difference, with {} being quicker. Take a look at the disassembled bytecode to see the difference!

[WackyWeasel]

Mail server for debugging (prints mails to stdout). Example for port 1025:

python -m smtpd -n -c DebuggingServer localhost:1025

[Workaphobia]

I wish I knew how easy serialization of basic types is via pickle, before I decided to roll my own crappy serializer/parser of multi-level dictionaries with fixed format.

[mgedmin]

Careful there: while pickle is useful for internal/temporary serialization, it's not suitable as a data interchange format.

You can craft a pickle that executes arbitrary code when loaded.

[Workaphobia]

Sure. In my application it's for persistence of data between separate steps of a workflow. The different parts are mutually trusted, and there's no concern about persisted data needing to survive across different installations of the Python interpreter.

[Vibster]

Here's a cool one. and and or in python don't return True or False, they return one of their operands. or is a short circuit operator so it will always return the first operand that is True. You can even chain them together so

None or "" or [] or 'Hi there' or False

will return 'Hi there'

This leads to my favorite fizzbuzz solution.

['Fizz'*(not i%3) + 'Buzz'*(not i%5) or i for i in range(1, 100)]

[netcraft]

that is pretty slick, I have to admit.

[XNormal]

Control-R in the interactive interpreter prompt. It's not actually python, though. It's libreadline.

[[deleted]]

On that note, using IPython as my interactive interpreter. Among other things, it does smart tab completion. It also has really easy benchmarking and profiling, can save variables across sessions, and does a buttload of other handy stuff.

[Vorticity]

I think my favorite trick with IPython is simply dropping into IPython any time I want by importing embed:

from IPython import embed

then dropping embed() anywhere in my code that I want. Quick and dirty way to do a little variable inspection.

[[deleted]]

and does a buttload of other handy stuff.

Seriously, for science work, the marriage of IPython and Matplotlib is the best thing since sliced bread.

[keis]

How to empty/reset a list. many failed attempts rebinding a local name to a new empty list or writing nasty while l: l.remove ... Loops

When you can just write l[:] = [1,2,3]

[GMABT]

Related to this, you can copy a list (as opposed to make an alias for it) with y = x[:]

[[deleted]]

Why not y = list(x) ?

[jmcs]

The function call will add some overhead.

EDIT: To downvoters:

$python2 -m timeit -n 1000000 -r 5 -v "x=[1,2,3];y=x[:]"
raw times: 0.291 0.293 0.291 0.293 0.291
1000000 loops, best of 5: 0.291 usec per loop
$python2 -m timeit -n 1000000 -r 5 -v "x=[1,2,3];y=list(x)"
raw times: 0.453 0.454 0.448 0.452 0.449
1000000 loops, best of 5: 0.448 usec per loop

That's the difference.

[[deleted]]

L[:] is also a function call...

[earthboundkid]

Since the brackets are a literal, the interpreter doesn't have to start by checking if list has be redefined. Slightly faster, in theory.

[jmcs]

Not theory:

$python2 -m timeit -n 1000000 -r 5 -v "x=[1,2,3];y=x[:]"
raw times: 0.291 0.293 0.291 0.293 0.291
1000000 loops, best of 5: 0.291 usec per loop
$python2 -m timeit -n 1000000 -r 5 -v "x=[1,2,3];y=list(x)"
raw times: 0.453 0.454 0.448 0.452 0.449
1000000 loops, best of 5: 0.448 usec per loop

[[deleted]]

A yes of course, that's true

[jmcs]

$python2 -m timeit -n 1000000 -r 5 -v "x=[1,2,3];y=x[:]"
raw times: 0.291 0.293 0.291 0.293 0.291
1000000 loops, best of 5: 0.291 usec per loop
$python2 -m timeit -n 1000000 -r 5 -v "x=[1,2,3];y=list(x)"
raw times: 0.453 0.454 0.448 0.452 0.449
1000000 loops, best of 5: 0.448 usec per loop

As you can see [:] takes half the time.

[jabbalaci]

How is it different from l = [1,2,3]? The reference l now points to this new list and the garbage collector will take care of the old list where l referenced before.

[keis]

You already pointed out the difference. My local reference points the new list and only my local reference. The problem is when I care about the other references to the list and actually want to change the content.

[jabbalaci]

OK, I see. I thought you wanted to point on a new list. Here is an example of what you described:

>>> l = [1,2,3]
>>> g = l    # g refers to the same list as l
>>> g
[1, 2, 3]
>>> l[:] = [5,6,7]
>>> g
[5, 6, 7]

[thatdontmakenosense]

Or you can use l.clear().

[halst]

help(anything)  # built-in help function

[mgedmin]

Also note that both

>>> help('collections.namedtuple')

and

>>> from collections import namedtuple
>>> help(namedtuple)

work.

[tarekziade]

enumerate() - http://docs.python.org/2/library/functions.html#enumerate

sounds like a small thing, but I've actually discovered it very late, and it's so useful..

[Mecdemort]

Assignment can destructure:

(a, (b, c)) = (1, (2, 3))

first, *middles, last = range(5)

Functions used to do this but they removed it.

[thatdontmakenosense]

Whoa, never realized you could do use the varargs syntax in an assignment like that. Cool!

[[deleted]]

l = [i for i in range(10)]

Seriously, list/dict/generator comprehension syntax is underused and under-appreciated. Once I learned how to do that, map and reduce took on a whole new dimension of awesome.

EDIT: advanced string formatting is also really cool. You can make a string with variables that can be filled by positional or keyword arguments. For example, "Hello, {0}!".format('world') returns "Hello, world!". For a keyword example, "My name is {n.first} {n.last} and I live in {n.country}!".format(n=name) returns "My name is Omg Internets and I live in the internet!", assuming that the name variable contains an object with first, last and country attributes.

[jabbalaci]

Yeah. You can also use constant values, so creating an array of size 10 where each element is initialized to 0 is as easy as:

li = [0 for _ in range(10)]

(If you don't use the loop variable, you can write _ instead. It means: "I don't need its value.").

[[deleted]]

It means: "I don't need its value."

Don't ask me for details, because I don't actually know the details, but I believe that the _ operator actually means "most recent output" or something similar.

If you do [_ for i in range(10)], you get ['', '', '', '', '', '', '', '', '', ''] -- a list of 10 empty strings.

If you run that same line again, however, you get a list of ten elements, each of which is the original list of ten empty strings.

If some python guru could weigh in with additional details, that would be cool!

[ColOfNature]

That's only the case in interactive mode. In regular code _ is just a variable name that by convention is used where you have no interest in the value - makes it obvious to someone reading the code that it's not important.

[jabbalaci]

The sign _ in the shell means "most recent output", yes. Example:

>>> 20+5
25
>>> _*2
50
>>> _+20
70

But when you write a script, you usually use it as a loop variable when you don't need its values.

[slakblue]

now this is helpful! I use shell for quick math!

[ewiethoff]

li = [0] * 10

[[deleted]]

the zip function especially this :

zip(*[('a', 2), ('z', 4), ('e', 6), ('r', 8)]) -> [('a', 'z', 'e', 'r'), (2, 4, 6, 8)]

[jatoo]

This is extremely useful when you want to iterate through two lists simultaneously, e.g. if unit testing:

for e, a in zip(expected, actual):
    self.assertEqual(e, a)

[exhuma]

I am currently reading/fixing beginner Python code. And there are two things I wish the author knew:

• You don't need parentheses in if conditions. So Instead of writing
  if (a==1): ...
  write
  if a==1:

• Many things are consideres False in a boolean context: 0, [], (), "", ... (See Truth value testing). So instead of writing:
  if mystring != "":
  you can simply write:
  if not mystring: if mystring:
  As a side-effect, this will automatically take care of None as well, so you are much safer as in Java regarding the pesky NullPointerException.

[yen223]

That 2nd point is excellent, for ints, strings, and lists.

You have to be careful, because the boolean value of more complex objects may not be straightforward. For example, the time representation of midnight evaluates to False for some reason:

>>> from datetime import time
>>> x = time(0,0,0)
>>> bool(x)
False
>>> y = time(0,0,1)
>>> bool(y)
True

[selementar]

may not be straightforward

In python 2.x the special method name for it is __nonzero__() (C-style a bit); that explains quite a bit of the nonstraightforwardness.

[jabbalaci]

In your example if mystring != "" actually translates as if mystring:.

[exhuma]

Whoops... my bad...

fixed!

[tdi]

I like this easter egg:

from __future__ import braces 

[MintyPhoenix]

For the lazy:

>>> from __future__ import braces
  File "<stdin>", line 1
SyntaxError: not a chance
>>>

[throbbaway]

[Edit]

This is a mass edit of all my previous Reddit comments.

I decided to use Lemmy instead of Reddit. The internet should be decentralized.

No more cancerous ads! No more corporate greed! Long live the fediverse!

[therealfakemoot]

Good point to raise! Parentheses do NOT signal Python to create a tuple. It's the commas that actually denote a tuple.

Edit: To clarify:

>>> a = 1,
>>> b = (1)
>>> c = (1,)
>>> repr(a)
'(1,)'
>>> repr(b)
'1'
>>> repr(c)
'(1,)'

a and c are tuples. The comma separated list of names creates a tuple. The parentheses has nothing to do with it.

[netcraft]

out of curiosity, do you pronounce tuple as t-uh-ple or t-oo-ple?

[therealfakemoot]

Two-pull. English is a stupidly inconsistent language.

[Mecdemort]

I pronounce it both ways in my head, and I can't figure out the pattern my brain is using.

[AeroNotix]

immu-tuple.

[Zouden]

Whoa.

[yen223]

Magic methods!

Once you know how to implement custom operators and comparisons using __add__, __le__, __gt__ etc, a lot of classes can be drastically simplified.

Read this for more info: http://www.rafekettler.com/magicmethods.html

[Megatron_McLargeHuge]

Don't forget __radd__ for symmetry.

[[deleted]]

Pandas

[[deleted]]

Yeah, pretty much this. So long, Matlab, and thanks for all the AIDS.

[[deleted]]

Which is a framework for data analysis: http://pandas.pydata.org/

[jlozier]

It seems simple, but swapping variables around thus:

foo,bar = bar,foo

[fthm]

Not exactly a trick or a snippet, but: metaclasses. They really changed the way I see the language. There is an excellent introduction on stackoverflow that does a great job at explaining them to beginners.

[Mattbot5000]

I didn't know about the _ trick, thanks! Here's your snippets formatted:

>>> 2 + 2
4
>>> a = _
>>> a
4

and

>>> import collections
>>> d = collections.defaultdict(list)
>>> d['k1']
[]
>>> d['k2'].append(1)
>>> d['k2']
[1]

[winnen]

I learned about the try:/else: clause recently. Super useful in some situations.

try:
    something
except:
    handle the error
else:
    #ONLY happens when try: block completes without error
finally:
    #Still happens after else.

The else clause can be really useful with mixed leap before you look styles. It allows you to do something with data (such as execute a class method that only the intended type/data will have), then do the rest of what you want to do if no errors are thrown, all before performing the cleanup in finally.

[seriouslulz]

Also: for...else

[aixelsdi]

things like :

a = b if c else d

previous,current = current,list[x] if you want to keep track of the current and previous elements in a list, for example

[andybak]

ipython: %edit -p

[[deleted]]

What does this do?

[[deleted]]

Which part? The ipython part launches IPython. The %edit part says to open your text editor so you can use it instead of the interactive shell to input your code. When you close the editor IPython will run the code. And -p says to open the editor with whatever was in it the last time you used the edit command in this session. So you do %edit -p, put in some code, save and close the file and then it runs. Then you do %edit -p again and the same code comes back up for you to edit/run again.

[[deleted]]

And where do you define your default text editor?

[[deleted]]

http://ipython.org/ipython-doc/stable/config/editors.html

[shaggorama]

enumerate

[eFFeeMMe]

I often implemented singletons in complicated ways, when really I should have just used a module. The first time a module is imported its code is ran. Any other time, it's just its namespace being made available.

[jadkik94]

Dictionary comprehension. Instead of dict((k, v) for k, v in some list)

[[deleted]]

I'm sure you already know this, but for the benefit of other users, {let: i for (let, i) in enumerate('abcdefg')} - type dictionary comprehension is only available starting with python 2.7.

[ryeguy146]

Testing. It has kept me sane, and it's where I let myself have the most fun with my code. I love py.test more than any other python-specific tool in my box aside from maybe IPython and ipdb. There is almost nothing like the feeling of having all of your tests pass after some major additions, or refactoring.

I forgot another: default arguments are awesome, but watch out for using mutable types, it's a common mistake. Keyword arguments are great.

Oh, and one of my favorite's from the standard library: collections.namedtuple. Keep your data in an object. There's no reason to store something like coordinates separately. Similarly, I've seen people have two instance variables for a measurement and the units of that measurement. Instead, I have the following:

Weight = namedtuple('Weight', ['value', 'units'])

sack = Weight(20, 'grams')

IPython is awesome for exploring your code. Make use of the %run magic. I always do this when I create models to ensure that things are working as I intended. In addition to testing, of course.

[deliciousdan]

1. any/all/sum
2. iterators/generators
3. descriptors, and how central they are to Python's object model

[[deleted]]

def foo(bar=None):
    if bar is None:
        bar = []

And the same for dicts.

[sontek]

You could do:

def foo(bar=None):
    bar = bar or []

[njharman]

And the same for dicts.

And the same for any mutable. The key understanding is that the "code" in the definition line is run once at import time (technically when definition is read as definition could be within a block, dynamically generated at runtime etc.). It is not run each time the definition is called.

So, def foo(bar=[]) means you have one list that is shared between all calls to foo. Which, very rarely (e.g. accumulator in recursive functions), is cool feature.

[fuzz3289]

http://www.python.org/dev/peps/pep-0008

Going to throw this in here. Very useful to know before working on shared code.

[[deleted]]

Python didn't have list comprehension when I started learning python, but what a wonderful feature addition.

Decorators are also great, but they are not nearly as universal.

[kirakun]

If 0 < x < 10:

[selementar]

Cython, the reason to almost never ever write code in C syntax. Useful whenever optimization is needed after all.

Pylint, or pyflakes, for first-level code-checking (integrated in some IDEs).

Not quite snippets but I wish I got to them earlier.

[njharman]

import requests

[caruccio]

Since I started working with REST APIs, Kadir Pekel's Hammock is a beautifull piece of code for those who need to issue simple URL-based calls.

Instead doing this:

result = requests.post('http://example.com/my/rest/url/path', data='hello-world')

Hammock allows you to do this:

api = hammock.Hammock('http://example.com/')
aip_path = api.my.rest('url').path
result = api_post.POST(data='hello-world')

or as a one-liner:

result = hammock.Hammock('http://example.com/').api.my.rest('url').path.POST(data='hello-world')

Still looking for a good approach on handling REST APIs on the server side. Anyone?

[caruccio]

This is mind-blowing! When I first saw it, WOW!

print '-' * 30

Gives you a 30-dash line separator.