This document discusses principles for writing readable Python code, including locality, consistency, and verbosity. It emphasizes that code should be written to be easily understood rather than clever, with related elements kept together, common patterns used consistently, and explanations provided through comments when the code is not obvious. The goal is for code to fit easily in the reader's head so it can be maintained and built upon over time by others, including the original author.

1. MAKING BEAUTIFUL
PYTHON CODE
Or Readability Counts
BY
JAIME BUELTA

2. Developers like
Python because code
is beautiful

3. Almost no one will appreciate it

4. (At least until there’s a problem)

5. BOSS DOES NOT CARE
worried about costs and stuff

6. CUSTOMERS DON’T CARE
worried about functionality and stuff

7. but your team will care

8. most of the time,
the effort difference
between good code
and bad code is small

9. MY
DREAM

15. CODE IS ALWAYS CHANGING

16. CODE NEEDS TO WORK

17. “There's a difference between
getting your hands dirty and
being dirty.”
DS Justin Ripley
(yes, the picture is not
from Luther, but from
The Good Cop)

18. WHAT MAKES BEAUTIFUL
CODE?

19. EASY TO UNDERSTAND

20. (THEREFORE, EASY TO
CHANGE)

21. NOT THE OTHER WAY
AROUND

22. OVERDESIGN

23. GOOD CODE

24. FITS IN YOUR HEAD

25. BAD
CODE...

27. System
Module
Function

28. Show how good you are HERE
Not here

31. LOCALITY
CONSISTENCY
VERBOSITY

32. LOCALITY
Keep related stuff together
CONSISTENCY
VERBOSITY

33. LOCALITY
CONSISTENCY
Use patterns
VERBOSITY

34. LOCALITY
CONSISTENCY
VERBOSITY
When in doubt, explain

35. in other words...
Be as OBVIOUS as possible

36. LOCALITY

37. MSG_TEMPLATE = ‘Template {date}: {msg}’
MORE_CONSTANTS...
....
def log_msg(message):
formatted_msg = MSG_TEMPLATE.format(
date=utcnow(),
msg=this_message
)
print formatted_msg

38. def log_msg(message):
MSG_TEMPLATE = ‘{date}: {msg}’
formatted_msg = MSG_TEMPLATE.format(
date=utcnow(),
msg=message
)
print formatted_msg

39. MSG_TEMPLATE = ‘{date}: {msg}’
def log_msg(message):
formatted_msg = TEMPLATE.format(
date=utcnow(),
msg=message
)
print formatted_msg

40. Related classes on
the same module
Keep files short
Function used only in
a module not in
independent module
Avoid
boilerplate
Separated
business logic

41. CONSISTENCY

42. Humans are amazing
recognizing patterns
(so good we tend to see too many)

43. PEP8 IS THE MOST
IMPORTANT PATTERN
COLLECTION OUT THERE

44. Abstract common operations
No getters and setters
List comprehensions
Decorators and with
statement
No private methods

45. I LOVE MY BRICK!
syndrome

46. VERBOSITY

47. data = "+RESP:GTTRI,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,"
"%s,%s,%s,%s,%s,%s,%s0" % (imei, number,
reserved_1, reserved_2,
gps_fix, speed,
heading, altitude, gps_accuracy,
longitude, latitude, send_time,
mcc, mnc, lac, cellid, ta,
count_num, ver)

48. data = (‘+RESP:GTTRI,{imei},{number},{reserved_1},’
‘{reserved_2},{gps_fix},{speed},{heading},’
‘{altitude},{gps_accuracy},{longitude},’
‘{latitude},{send_time}, {mmc}, {lac}, {cellid}’
‘{ta},{count_num}, {version}’).format(
imei=imei,
number=number,
reserved_1=reserved_1,
reserved_2=reserved_2,
gps_fix=gps_fix,
speed=speed,
heading=heading,
altitude=altitude,
gps_accuracy=gps_accuracy,
longitude=longitude,
latitude=latitude,
send_time=send_time,
mcc=mcc,
mnc=mnc,
lac=lac,
cellid=cellid,
ta=ta,
count_num=count_num,
version=ver,
)

49. WHEN IN DOUBT,
COMMENT

50. PUTTING ALL
TOGETHER

51. results = []
for row in query_results:
tag, value, updated = row
if value and updated > last_time:
TEMP = ‘tag: {0}, value: {1}
result = TEMP.format(tag,
value)
results.append(result)

52. def format_result(row):
tag, value, _ = row
TEMP = ‘tag: {0}, value: {1}’
return TEMP.format(tag, value)
def interesting(row):
_, value, updated = row
return value and updated > last_time
results = [format_result(row)
for row in query_results
if interesting(row)]

53. SMART IS THE ENEMY OF
READABILITY

54. HAVE A GOOD REASON TO
BE SMART
And comment accordingly

55. ONE DAY, SOMEONE WILL BE
SURPRISED WITH YOUR CODE

56. YOURSELF!!!

57. SO, REMEMBER

59. BE OBVIOUS

60. ASSUME YOU CAN’T FIT A LOT
OF CODE ON YOUR HEAD

61. BE SMART IN SYSTEMS, NOT
IN FUNCTIONS

62. LOCALITY
CONSISTENCY
VERBOSITY

63. Tell your buddies how much you
appreciate them writing simple code!