Just like any other form of art, Programming can always be improved. In daily grind to deliver working software we might forget details and `JUST DO IT`. In our quest to improve our python coding we've come across couple of good Python videos that will help you take you code to next level.
Following is summary of two talks Designing Poetic APIs by Erik Rose and Transforming Code into Beautiful, Idiomatic Python by Raymond Hettinger. On twitter you can find them on @erikrose and @raymondh
Eric Rose’s Github has more fascinating stuff. His talk is a good investment of 37 minutes of your time. Following is summary we’ve compiled from the video:
get(key, default) is better than fetch(default, key) because it sticks with current conventions of PythonRDH Talks is interesting list. His talk is another interesting one. Here is the summary
Looping over a range of numbers
for i in [0, 1, 2, 3, 4, 5]:
print i**2
# Better way
for i in range(6):
print i**2
# Faster way
# Ugly way, in Python 3K this is renamed to xrange
for i in xrange(6):
print i**2Looping over a collection
colors = ['red', 'green', 'blue', 'yellow']
for i in range(len(colors)):
print colors[i]
# Better way
for color in colors:
print colorLooping backwards
colors = ['red', 'green', 'blue', 'yellow']
for i in range(len(colors)-1, -1, -1):
print colors[i]
# This is faster and beautiful
for color in reversed(colors):
print colorLooping over collection and indicies
colors = ['red', 'green', 'blue', 'yellow']
for i in range(len(colors)):
print i, colors[i]
# Better way
for i, color in enumerate(color):
print i, colorLooping over two collections at once
names = ['raymond', 'rachel', 'matthew']
colors = ['red', 'green', 'blue', 'yellow']
n = min(len(names), len(colors))
for i in range(n):
print names[i], "->", colors[i]
# Better way
# But takes more memory
for name, color in zip(names, colors):
print name, "->", color
# Idiomatic way
# Consumes less memory
for name, color in izip(names, colors):
print name, "->", colorLooping over sorted order
colors = ['red', 'green', 'blue', 'yellow']
for color in sorted(colors):
print color
for color in sorted(colors, reverse=True):
print colorCustom sort order
colors = ['red', 'green', 'blue', 'yellow']
def compare_length(c1, c2):
if len(c1) < len(c2): return -1
if len(c1) > len(c2): return 1
return 0
print sorted(colors, cmp=compare_length)
# Better way
print sorted(colors, key=len)Call a function until a sentinal value. Note: Partial take a function with one or more arguments and returns a function with fewer argument.
blocks = []
while True:
block = f.read(32)
if block == '':
break
blocks.append(block)
# Better way
blocks = []
# iter function takes two arguments
# 1. Function you call over and over again
# 2. Sentinel value
for block in iter(partial(f.read, 32), ''):
blocks.append(block)Distinguish multiple exit point in loops
def find(seq, target):
found = False
for i, value in enumerate(seq):
if value == target:
found = True
break
if not found:
return -1
return i
# Better way
def find(seq, target):
for i, value in enumerate(seq):
if value == target:
found = True
break
else:
return -1
return iLooping over dictionary keys
d = {'matthew': 'blue', 'rachel': 'green', 'raymond': 'red'}
for k in d:
print k
```Looping over dictionary keys and values
for k, v in d.items():
print k, "->", v
# Better way
for k,v in d.iteritems():
print k, "->", v
```Construct a dictionary in pairs
names = ['matthew', 'rachel', 'raymond']
colors = ['blue', 'green', 'raymond']
d = dict(izip(names, colors))
d = dict(enumerate(names))
```Counting with dictionaries
colors = ['red', 'green', 'red', 'blue' 'green', 'red']
d = {}
for color in colors:
if color not in d:
d[color] = 0
d[color] += 1
# Better way
d = {}
for color in colors:
d[color] = d.get(color, 0) + 1
# Idiomatic way
from collections import defaultdict
d = defaultdict(int)
for color in colors:
d[color] += 1
```Grouping with dictionaries
names = ['raymond', 'rachel', 'matthew', 'roger', 'betty', 'melissa', 'judith', 'charlie']
d = {}
for name in names:
key = len(name)
if key not in d:
d[key] = []
d[key].append(name)
# Better way
d = {}
for name in names:
key = len(name)
d.setdefault(key, []).append(name)
# Better way
d = defaultdict(list)
for name in names:
key = len(name)
d[name].append(key)
```Is a dictionary popitem() atomic?
d = {'matthew': 'blue', 'rachel': 'green', 'raymond': 'red'}
# Pop item is atomic so it can be used between threads
while d:
key, value = d.popitem()
print key, "->", value
```Linking dictionaires (Or chaining them)
default = {}
d = defaults.copy()
d.update(os.environ)
d.update(command_line_args)
d.ChainMap(command_line_args, os.environ, defaults)
```Clarify function calls with keyword arguments (Good activity for someone who doesn’t know the codebase)
twitter_search('@obama', False, 20, True)
# More readable
twitter_search('@obama', retweets=False, numtweets=20, popular=True)
```Clarify multiple return values with named tuples
doctest.testmod()
(0, 4)
# This is more readable and result of NamedTuple
doctest.testmod()
TestResults(failed=0, attempted=4)
# How named tuples are used
TestResults = namedtuple('TestResult', ['failed', 'attempted'])
```Unpacking Sequences
p = 'a', 'b', 'c', d
fname = p[0]
lname = p[1]
age = p[2]
email = p[3]
fname, lname, age, email = p
```Update multiple state variables
def fibonacci(n):
x = 0
y = 1
for i in range(n):
print x
t = y
y = x + y
x = t
# Better version
def fibonacci(n):
x, y = 0, 1
for i in range(n):
print x
x, y = y, x+y
```Using decorators to factor-out administrative logic
def web_lookup(url, saved={}):
if url in saved:
return saved[url]
page = urllib.urlopen(url).read()
saved[url] = page
return page
# Better way
@cache
def web_lookup(url):
return urllib.urlopen(url).read()
# Logic for decorator
def cache(func):
saved = {}
@wraps(func)
def newfunc(*args):
if args in saved:
return newfunc(*args)
result = func(*args)
saved[*args] = result
return result
return newfunc
```How to open and close files
f = open('data.txt')
try:
data = f.read()
finally:
f.close()
# Better way, closes file automatically
with open('data.txt') as f:
data = f.read()
```Factor-out temporary context
try:
os.remove('somefile.tmp')
except OSError:
pass
# Better way
with ignored(OSError):
os.remove('somefile.tmp')
```Have a startup idea you’d like to see come to life? Have a legacy codebase that needs upgradation? Have a deadline and want to get job done on budget? Look no further, Hire Fafadia Tech
Why select Fafadia Tech?