Expert python programming become an ace python programmer by learning best coding practices and advance level concepts with python 3 5 2nd edition

Expert Python Programming
Second Edition

Become an ace Python programmer by learning best
coding practices and advance-level concepts with
Python 3.5

Michał Jaworski
Tarek Ziadé

BIRMINGHAM - MUMBAI


Expert Python Programming
Second Edition

Copyright © 2016 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval
system, or transmitted in any form or by any means, without the prior written
permission of the publisher, except in the case of brief quotations embedded in
critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy
of the information presented. However, the information contained in this book is
sold without warranty, either express or implied. Neither the authors, nor Packt
Publishing, and its dealers and distributors will be held liable for any damages
caused or alleged to be caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the
companies and products mentioned in this book by the appropriate use of capitals.
However, Packt Publishing cannot guarantee the accuracy of this information.

First published: September 2008
Second edition: May 2016

Production reference: 1160516

Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham B3 2PB, UK.
ISBN 978-1-78588-685-0
www.packtpub.com


Credits
Authors
Michał Jaworski

Proofreader
Safis Editing

Tarek Ziadé
Indexer
Reviewer

Rekha Nair

Facundo Batista
Graphics
Commissioning Editor

Jason Monteiro

Kunal Parikh
Production Coordinator
Acquisition Editor

Aparna Bhagat

Meeta Rajani
Cover Work
Technical Editor
Pankaj Kadam
Copy Editor
Laxmi Subramanian

Aparna Bhagat


About the Authors
Michał Jaworski has 7 years of experience in Python. He is also the creator of

graceful, which is a REST framework built on top of falcon. He has been in various
roles at different companies: from an ordinary full-stack developer through software
architect to VP of engineering in a fast-paced start-up company. He is currently a
lead backend engineer in TV Store team at Opera Software. He is highly experienced
in designing high-performance distributed services. He is also an active contributor
to some of the popular Python open source projects.

Tarek Ziadé is an engineering manager at Mozilla, working with a team

specialized in building web services in Python at scale for Firefox. He's contributed
to the Python packaging effort and has worked with a lot of different Python web
frameworks since Zope in the early days.
Tarek has also created Afpy, the French Python User Group, and has written two
books on Python in French. He has delivered numerous talks and tutorials in French
at international events such as Solutions Linux, PyCon, OSCON, and EuroPython.


About the Reviewer
Facundo Batista is a specialist in the Python programming language, with more
than 15 years of experience with it. He is a core developer of the language, and a
member by merit of the Python Software Foundation. He also received the 2009
Community Service Award for organizing PyCon Argentina and the Argentinian
Python community as well as contributions to the standard library and work in
translating the Python documentation.

He delivers talks in the main Python conferences in Argentina and other countries
(The United States and Europe). In general, he has strong distributed collaborative
experience from being involved in FLOSS development and working with people
around the globe for more than 10 years.
He worked as a telecommunication engineer at Telefónica Móviles and Ericsson, and
as a Python expert at Cyclelogic (developer in chief) and Canonical (senior software
developer, his current position).
He also loves playing tennis, and is a father of two wonderful children.


www.PacktPub.com
eBooks, discount offers, and more

Did you know that Packt offers eBook versions of every book published, with PDF
and ePub files available? You can upgrade to the eBook version at www.PacktPub.com
and as a print book customer, you are entitled to a discount on the eBook copy. Get in
touch with us at for more details.
At www.PacktPub.com, you can also read a collection of free technical articles, sign
up for a range of free newsletters and receive exclusive discounts and offers on
Packt books and eBooks.
TM

/>
Do you need instant solutions to your IT questions? PacktLib is Packt's online digital
book library. Here, you can search, access, and read Packt's entire library of books.

Why subscribe?

• Fully searchable across every book published by Packt
• Copy and paste, print, and bookmark content
• On demand and accessible via a web browser


Table of Contents
Preface
Chapter 1: Current Status of Python

Where are we now and where we are going?
Why and how does Python change?
Getting up to date with changes – PEP documents
Python 3 adoption at the time of writing this book
The main differences between Python 3 and Python 2
Why should I care?

The main syntax differences and common pitfalls
Syntax changes
Changes in the standard library
Changes in datatypes and collections

xi
1
2
2
3
4
5
5
5

6
7
8

The popular tools and techniques used for maintaining cross-version
compatibility8
Not only CPython
12
Why should I care?
13
Stackless Python
13
Jython
14
IronPython

14
PyPy15
Modern approaches to Python development
16
Application-level isolation of Python environments
17
Why isolation?
19
Popular solutions
21

virtualenv21
venv23
buildout
24

Which one to choose?

24

[i]


Table of Contents

System-level environment isolation
Virtual development environments using Vagrant
Containerization versus virtualization
Popular productivity tools
Custom Python shells – IPython, bpython, ptpython, and so on

25
26
27
28
29

Interactive debuggers
Useful resources
Summary

31
32
33

Setting up the PYTHONSTARTUP environment variable
30
IPython
30
bpython
30
ptpython31

Chapter 2: Syntax Best Practices – below the Class Level
Python's built-in types
Strings and bytes
Implementation details
String concatenation

35

36
36

38
39

Collections

Lists and tuples
Dictionaries
Sets
Beyond basic collections – the collections module

40

40
45
49
50

Advanced syntax
51
Iterators51
The yield statement
52
Decorators56
General syntax and possible implementations
Usage and useful examples

Context managers – the with statement

General syntax and possible implementations

57
61

68

69

Other syntax elements you may not know yet
The for … else … statement
Function annotations

72
73
73

Summary

75

The general syntax
The possible uses

Chapter 3: Syntax Best Practices – above the Class Level
Subclassing built-in types
Accessing methods from superclasses
Old-style classes and super in Python 2
Understanding Python's Method Resolution Order

[ ii ]

74
74

77
78
80
82
83


Table of Contents

super pitfalls

87

Mixing super and explicit class calls
Heterogeneous arguments

87
89

Best practices
90
Advanced attribute access patterns
91
Descriptors92
Real-life example – lazily evaluated attributes

95

Properties98
Slots
101
Metaprogramming
102
Decorators – a method of metaprogramming
103
Class decorators
103
Using the __new__() method to override instance creation process
105
Metaclasses
108
The general syntax
New Python 3 syntax for metaclasses
Metaclass usage
Metaclass pitfalls

109
112
115
115

Some tips on code generation

116

exec, eval, and compile
Abstract Syntax Tree
Projects using code generation patterns

117
118
120

Summary

Chapter 4: Choosing Good Names

123

125

PEP 8 and naming best practices
125
Why and when to follow PEP 8?
126
Beyond PEP 8 – team-specific style guidelines
126
Naming styles
127
Variables127

Constants128
Naming and usage
129
Public and private variables

130
Functions and methods
131
The private controversy
132
Special methods
134
Arguments
134
Properties
134
Classes135
Modules and packages
135

The naming guide
Using the has or is prefix for Boolean elements
Using plurals for variables that are collections
Using explicit names for dictionaries
[ iii ]

136
136
136
136


Table of Contents

Avoiding generic names

Avoiding existing names
Best practices for arguments
Building arguments by iterative design
Trust the arguments and your tests
Using *args and **kwargs magic arguments carefully
Class names
Module and package names
Useful tools
Pylint
pep8 and flake8
Summary

Chapter 5: Writing a Package

Creating a package
The confusing state of Python packaging tools

The current landscape of Python packaging thanks to PyPA
Tool recommendations

136
138
138
139
139
141
143
143
144
144

146
147

149

149
150

150
151

Project configuration

152

The custom setup command
Working with packages during development

161
161

setup.py152
setup.cfg153
MANIFEST.in
154
Most important metadata
154
Trove classifiers
155
Common patterns

156

setup.py install
Uninstalling packages
setup.py develop or pip -e

Namespace packages
Why is it useful?
PEP 420 – implicit namespace packages
Namespace packages in previous Python versions
Uploading a package
PyPI – Python Package Index
Uploading to PyPI – or other package index
.pypirc

162
162
162

163
163
166
167
168
169

169
170

Source packages versus built packages

171

Standalone executables
When are standalone executables useful?

174
175

sdist171
bdist and wheels
172

[ iv ]


Table of Contents

Popular tools

176

Security of Python code in executable packages

184

PyInstaller177
cx_Freeze
181
py2exe and py2app

183
Making decompilation harder

Summary

185

186

Chapter 6: Deploying Code

The Twelve-Factor App
Deployment automation using Fabric
Your own package index or index mirror
PyPI mirroring
Deployment using a package
Common conventions and practices
The filesystem hierarchy
Isolation
Using process supervision tools
Application code should be run in user space
Using reverse HTTP proxies
Reloading processes gracefully
Code instrumentation and monitoring
Logging errors – sentry/raven
Monitoring system and application metrics
Dealing with application logs
Basic low-level log practices
Tools for log processing

Summary

Chapter 7: Python Extensions in Other Languages
Different language means – C or C++
How do extensions in C or C++ work
Why you might want to use extensions
Improving performance in critical code sections
Integrating existing code written in different languages
Integrating third-party dynamic libraries
Creating custom datatypes
Writing extensions
Pure C extensions
A closer look at Python/C API
Calling and binding conventions
Exception handling
Releasing GIL
Reference counting

[v]

187

188
189
195
196
197
207
207
207

208
210
210
211
212
213
215
218

218
220

223

225

226
226
228
228
229
230
230
230
231

235
240
242
244

246


Table of Contents

Cython

248

Cython as a source to source compiler
Cython as a language

248
250

Challenges
253
Additional complexity
253
Debugging
254
Interfacing with dynamic libraries without extensions
255
ctypes255
Loading libraries
Calling C functions using ctypes
Passing Python functions as C callbacks

255
257

258

CFFI262
Summary
263

Chapter 8: Managing Code

265

Version control systems
Centralized systems
Distributed systems

265
266
268

Distributed strategies

Centralized or distributed?
Use Git if you can
Git flow and GitHub flow
Continuous development processes
Continuous integration
Testing every commit
Merge testing through CI
Matrix testing

270

271
271
272
276
277

278
279
280

Continuous delivery
Continuous deployment
Popular tools for continuous integration

280
281
282

Choosing the right tool and common pitfalls

290

Jenkins
282
Buildbot286
Travis CI
288
GitLab CI
290

Problem 1 – too complex build strategies
Problem 2 – too long building time
Problem 3 – external job definitions
Problem 4 – lack of isolation

Summary

Chapter 9: Documenting Your Project
The seven rules of technical writing
Write in two steps
Target the readership

[ vi ]

291
291
292
293

294

295

295
296
297


Table of Contents

Use a simple style
Limit the scope of information
Use realistic code examples
Use a light but sufficient approach
Use templates
A reStructuredText primer
Section structure
Lists
Inline markup
Literal block
Links
Building the documentation
Building the portfolio

298
299
299
300
301
301
303
305
306
306
307
308
308

Making your own portfolio
Building the landscape

315
316

Documentation building and continuous integration
Summary

322
323

Design
309
Usage
310
Operations315

Producer's layout
Consumer's layout

Chapter 10: Test-Driven Development
I don't test
Test-driven development principles

Preventing software regression
Improving code quality
Providing the best developer documentation
Producing robust code faster

317
318

325

325
326

328
329
329
330

What kind of tests?

330

Python standard test tools

333

Acceptance tests
Unit tests
Functional tests
Integration tests
Load and performance testing
Code quality testing

330
331
331
332

332
333

unittest333
doctest337

I do test
unittest pitfalls
unittest alternatives

339
339
340

nose
py.test

340
344

[ vii ]


Table of Contents

Testing coverage
Fakes and mocks

348
351

Testing environment and dependency compatibility

358

Document-driven development

362

Building a fake
Using mocks

Dependency matrix testing
Writing a story

351
356
358
362

Summary

Chapter 11: Optimization – General Principles and Profiling
Techniques
The three rules of optimization
Make it work first
Work from the user's point of view
Keep the code readable and maintainable
Optimization strategy
Find another culprit

Scale the hardware
Writing a speed test
Finding bottlenecks
Profiling CPU usage
Macro-profiling
Micro-profiling
Measuring Pystones

364

365
365
366
367
367
368
368
368
369
370
370

371
375
378

Profiling memory usage

379

Profiling network usage
Summary

391
392

How Python deals with memory
Profiling memory
C code memory leaks

379
382
390

Chapter 12: Optimization – Some Powerful Techniques
Reducing the complexity
Cyclomatic complexity
The big O notation
Simplifying
Searching in a list
Using a set instead of a list

393

394
396
396
399
399

400

Using collections
deque
defaultdict
namedtuple

401
401
403
404
[ viii ]


Table of Contents

Using architectural trade-offs
Using heuristics and approximation algorithms
Using task queues and delayed processing
Using probabilistic data structures
Caching
Deterministic caching
Nondeterministic caching
Cache services

405
405
406
410
411

412
415
416

Summary

419

Memcached

Chapter 13: Concurrency

416

421

Why concurrency?
Multithreading
What is multithreading?
How Python deals with threads
When should threading be used?

422
423
424
425
426

Building responsive interfaces
Delegating work

Multiuser applications
An example of a threaded application

426
426
427
428

Multiprocessing
The built-in multiprocessing module

442
445

Asynchronous programming
Cooperative multitasking and asynchronous I/O
Python async and await keywords
asyncio in older versions of Python
A practical example of asynchronous programming
Integrating nonasynchronous code with async using futures

451
452
453
457
458
461

Summary

465

Using process pools
Using multiprocessing.dummy as a multithreading interface

Executors and futures
Using executors in an event loop

Chapter 14: Useful Design Patterns
Creational patterns
Singleton
Structural patterns
Adapter
Interfaces

449
450

462
464

467

467
468
471
472

474

Proxy
Facade

487
489
[ ix ]


Table of Contents

Behavioral patterns
Observer
Visitor
Template
Summary

490
490
492
495
498

Index

499

[x]


Preface

Python rocks!
From the earliest version in the late 1980s to the current version, it has evolved with
the same philosophy: providing a multiparadigm programming language with
readability and productivity in mind.
People used to see Python as yet another scripting language and wouldn't feel right
about using it to build large systems. However, over the years and thanks to some
pioneer companies, it became obvious that Python could be used to build almost any
kind of system.
In fact, many developers that come from another language are charmed by Python
and make it their language of choice.
This is something you are probably aware of if you have bought this book, so there's
no need to convince you about the merits of the language any further.
This book is written to express many years of experience of building all kinds of
applications with Python, from small system scripts done in a couple of hours to
very large applications written by dozens of developers over several years.
It describes the best practices used by developers when working with Python.
This book covers some topics that do not focus on the language itself but rather on
the tools and techniques used to work with it.
In other words, this book describes how an advanced Python developer works
every day.

[ xi ]


Preface

What this book covers

Chapter 1, Current Status of Python, showcases the current state of the Python
language and its community. It shows how Python is constantly changing, why it

is changing, and also why these facts are important for anyone who wants to call
themselves a Python professional. This chapter also features the most popular and
canonical ways of working in Python—popular productivity tools and conventions
that are de facto standards now.
Chapter 2, Syntax Best Practices – below the Class Level, presents iterators, generators,
descriptors, and so on, in an advanced way. It also covers useful notes about Python
idioms and internal CPython types implementations with their computational
complexities as a rationale for showcased idioms.
Chapter 3, Syntax Best Practices – above the Class Level, explains syntax best practices,
but focuses above the class level. It covers more advanced object-oriented concepts
and mechanisms available in Python. This knowledge is required in order to
understand the last section of the chapter, which presents different approaches
to metaprogramming in Python.
Chapter 4, Choosing Good Names, involves choosing good names. It is an extension
to PEP 8 with naming best practices, but also gives tips on designing good APIs.
Chapter 5, Writing a Package, explains how to create the Python package and which
tools to use in order to properly distribute it on the official Python Package Index
or any other package repository. Information about packages is supplemented
with a brief review of the tools that allow you to create standalone executables
from Python sources.
Chapter 6, Deploying Code, aims mostly at Python web developers and backend
engineers, because it deals with code deployments. It explains how Python
applications should be built in order to be easily deployed to remote servers and
what tools you can use in order to automate that process. This chapter dovetails
with Chapter 5, Writing a Package, because it shows how packages and private
package repositories can be used to streamline your application deployments.
Chapter 7, Python Extensions in Other Languages, explains why writing C extensions
for Python might be a good solution sometimes. It also shows that it is not as hard
as it seems to be as long as the proper tools are used.
Chapter 8, Managing Code, gives some insight into how a project code base can be

managed and explains how to set up various continuous development processes.
Chapter 9, Documenting Your Project, covers documentation and provides tips on
technical writing and how Python projects should be documented.
[ xii ]


Preface

Chapter 10, Test-Driven Development, explains the basic principles of test-driven
development and the tools that can be used in this development methodology.
Chapter 11, Optimization – General Principles and Profiling Techniques, explains
optimization. It provides profiling techniques and an optimization strategy guideline.
Chapter 12, Optimization – Some Powerful Techniques, extends Chapter 11, Optimization
– General Principles and Profiling Techniques, by providing some common solutions to
the performance problems that are often found in Python programs.
Chapter 13, Concurrency, introduces the vast topic of concurrency in Python. It explains
what concurrency is, when it might be necessary to write concurrent applications, and
what are the main approaches to concurrency for Python programmers.
Chapter 14, Useful Design Patterns, concludes the book with a set of useful design
patterns and example implementations in Python.

What you need for this book

This book is written for developers who work under any operating system for which
Python 3 is available.
This is not a book for beginners, so I assume you have Python installed in your
environment or know how to install it. Anyway, this book takes into account the fact
that not everyone needs to be fully aware of the latest Python features or officially
recommended tools. This is why the first chapter provides a recap of common
utilities (such as virtual environments and pip) that are now considered standard

tools of professional Python developers.

Who this book is for

This book is written for Python developers who wish to go further in mastering
Python. And by developers I mean mostly professionals, so programmers who write
software in Python for a living. This is because it focuses mostly on tools and practices
that are crucial for creating performant, reliable, and maintainable software in Python.
It does not mean that hobbyists won't find anything interesting. This book should be
great for anyone who is interested in learning advance-level concepts with Python.
Anyone who has basic Python skills should be able to follow the content of the book,
although it might require some additional effort from less experienced programmers.
It should also be a good introduction to Python 3.5 for those who are still a bit behind
and continue to use Python in version 2.7 or older.

[ xiii ]


Preface

Finally, the groups that should benefit most from reading this book are web
developers and backend engineers. This is because of two topics featured in here
that are especially important in their areas of work: reliable code deployments
and concurrency.

Conventions

In this book, you will find a number of text styles that distinguish between different
kinds of information. Here are some examples of these styles and an explanation of
their meaning.

Code words in text, database table names, folder names, filenames, file extensions,
pathnames, dummy URLs, user input, and Twitter handles are shown as follows:
"Use the str.encode(encoding, errors) method, which encodes the string using
a registered codec for encoding."
A block of code is set as follows:
[print("hello world")
print "goodbye python2"

When we wish to draw your attention to a particular part of a code block, the
relevant lines or items are set in bold:
cdef long long fibonacci_cc(unsigned int n) nogil:
if n < 2:
return n
else:
return fibonacci_cc(n - 1) + fibonacci_cc(n - 2)

Any command-line input or output is written as follows:
$ pip show pip
--Metadata-Version: 2.0
Name: pip
Version: 7.1.2
Summary: The PyPA recommended tool for installing Python packages.
Home-page: />Author: The pip developers
Author-email:

[ xiv ]


Preface
License: MIT

Location: /usr/lib/python2.7/site-packages
Requires:

New terms and important words are shown in bold. Words that you see on
the screen, for example, in menus or dialog boxes, appear in the text like this:
"Clicking the Next button moves you to the next screen."

Warnings or important notes appear in a box like this.

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about
this book—what you liked or disliked. Reader feedback is important for us as it
helps us develop titles that you will really get the most out of.
To send us general feedback, simply e-mail , and mention
the book's title in the subject of your message.
If there is a topic that you have expertise in and you are interested in either writing
or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things
to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book from your account at
. If you purchased this book elsewhere, you can

visit and register to have the files e-mailed
directly to you.

[ xv ]


Preface

You can download the code files by following these steps:
1. Log in or register to our website using your e-mail address and password.
2. Hover the mouse pointer on the SUPPORT tab at the top.
3. Click on Code Downloads & Errata.
4. Enter the name of the book in the Search box.
5. Select the book for which you're looking to download the code files.
6. Choose from the drop-down menu where you purchased this book from.
7. Click on Code Download.
You can also download the code files by clicking on the Code Files button on the
book's webpage at the Packt Publishing website. This page can be accessed by
entering the book's name in the Search box. Please note that you need to be logged
in to your Packt account.
Once the file is downloaded, please make sure that you unzip or extract the folder
using the latest version of:
• WinRAR / 7-Zip for Windows
• Zipeg / iZip / UnRarX for Mac
• 7-Zip / PeaZip for Linux
The code bundle for the book is also hosted on GitHub at />PacktPublishing/Expert-Python-Programming_Second-Edition. We also have
other code bundles from our rich catalog of books and videos available at https://
github.com/PacktPublishing/. Check them out!

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes
do happen. If you find a mistake in one of our books—maybe a mistake in the text or
the code—we would be grateful if you could report this to us. By doing so, you can
save other readers from frustration and help us improve subsequent versions of this
book. If you find any errata, please report them by visiting ktpub.
com/submit-errata, selecting your book, clicking on the Errata Submission Form
link, and entering the details of your errata. Once your errata are verified, your
submission will be accepted and the errata will be uploaded to our website or added
to any list of existing errata under the Errata section of that title.
To view the previously submitted errata, go to />content/support and enter the name of the book in the search field. The required
information will appear under the Errata section.
[ xvi ]


Preface

Piracy

Piracy of copyrighted material on the Internet is an ongoing problem across all
media. At Packt, we take the protection of our copyright and licenses very seriously.
If you come across any illegal copies of our works in any form on the Internet, please
provide us with the location address or website name immediately so that we can
pursue a remedy.
Please contact us at with a link to the suspected
pirated material.
We appreciate your help in protecting our authors and our ability to bring you
valuable content.

Questions

If you have a problem with any aspect of this book, you can contact us at
, and we will do our best to address the problem.

[ xvii ]