Idiomatic Python

Idiomatic Python

P.C. Shyamshankar

PyCon India 2009

September 25, 2009

P.C. Shyamshankar (PyCon India 2009) Idiomatic Python September 25, 2009 1 / 35

Outline

1 Introduction

2 IdiomsAccumulationForgivenessLazinessComprehensionContextOdds and Ends


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!


Idioms

An Unwritten Rule

A common use-case.

Usually to make the code better in some way:I ReadabilityI SpeedI Resource Usage


Outline

1 Introduction



Putting strings together.

Strings are immutable

String addition creates copies.


Join, Don’t Add.

s = ’’for i in list_of_strings :

s += i

s = ’’.join(list_of_strings)


That’s just what everyone says.

String addition isn’t evil, just asymptotically slow.


Outline

1 Introduction



EAFP

It’s Easier to Ask Forgiveness than Permission.

Asking permission is to LBYL

But it depends on the context.


A Story of Keys in a Dict

If the key is in the dict, increment its value.

If not, set its value to 1.


Asking for Permission

if key in my_dict :my_dict[key] += 1

else :my_dict[key] == 1


Asking for Forgiveness

try :my_dict[key] += 1

except KeyError :my_dict[key] = 1


Choosing the right time

Use the first approach, if you’re more likely to succeed.

Use the second if you’re more likely to fail.


So many choices!

my dict.get(key, 0) += 1

my dict.setdefault(key, []).append(value)

my dict = collections.defaultdict(int)

my dict = collections.Counter()


Outline

1 Introduction



Be Lazy!

Compute only what you need to compute. It saves time.

Store only what you need to store. It saves space.


Enter Iterators

Maintain state.

Transit between states.


A simple Fibonacci Iterator

class Fibonacci :def __init__(self) :

self.p, self.q = 0, 1def __iter__(self) :

return self

def __next__(self) :self.p, self.q = self.q, self.p + self.qreturn self.p

f = Fibonacci()for i in range(10) :

print(next(f))


Enter Generators

An easier way to be lazy.

Define functions, but use yield instead of return.

The generator picks up where it left off.


A simpler Fibonacci Generator

def Fibonacci() :p, q = 0, 1

while True :p, q = q, p + qyield p


Outline

1 Introduction



What are comprehensions?

A short-hand form for building:I Lists [func(i) for i in sequence]I Generators (func(i) for i in sequence)I Sets {func(i) for i in sequence}I Dicts {key : func(key) for key in sequence}


They’re short. What else?

Comprehensions are fast.

Faster than looping.


Outline

1 Introduction



Motivation

A common pattern:I SetupI TryI ExceptI Finally


A common use case

connection = connection_to_db(db_info)

try :do_some_stuff_with_db(connection, data)

except BorkedOperation :handle_it()

finally :clean_up_the_mess()


The ”with” statement.

Simplifies the above usage pattern.

def insert_data(db_info, data) :with db_connection(db_info) as connection :

do_some_stuff_with_db(db_info, data)

Much simpler.

But where did the complexity go?


Context Managers

Classes that implement enter and exit methods.

Encapsulates the relevant logic within these methods.


In Context

enter method of the context manager is called, result stored invar.

Block is executed.

exit method of the context manager is called.


Outline

1 Introduction



Odds and Ends

Enumerate, don’t index.

Unpack tuples, don’t index.

Assign to slices, don’t loop over them.

Duck Type, don’t Check Type.

Use your head.


DRY

Don’t Repeat Yourself.

itertools are meant to help you process data.

collections are meant to help you hold data.


Thank you.

That’s it.


Idiomatic Python

Technology

Transcript of Idiomatic Python