Secret Recipes of the Python Ninja
Over 70 recipes that uncover powerful programming tactics in Python
Cody Jackson
- 380 pages
- English
- ePUB (mobile friendly)
- Available on iOS & Android
Secret Recipes of the Python Ninja
Over 70 recipes that uncover powerful programming tactics in Python
Cody Jackson
About This Book
Test your Python programming skills by solving real-world problems
Key Features
- Access built-in documentation tools and improve your code.
- Discover how to make the best use of decorator and generator functions
- Enhance speed and improve concurrency by conjuring tricks from the PyPy project
Book Description
This book covers the unexplored secrets of Python, delve into its depths, and uncover its mysteries.
You'll unearth secrets related to the implementation of the standard library, by looking at how modules actually work. You'll understand the implementation of collections, decimals, and fraction modules. If you haven't used decorators, coroutines, and generator functions much before, as you make your way through the recipes, you'll learn what you've been missing out on.
We'll cover internal special methods in detail, so you understand what they are and how they can be used to improve the engineering decisions you make. Next, you'll explore the CPython interpreter, which is a treasure trove of secret hacks that not many programmers are aware of. We'll take you through the depths of the PyPy project, where you'll come across several exciting ways that you can improve speed and concurrency.
Finally, we'll take time to explore the PEPs of the latest versions to discover some interesting hacks.
What you will learn
- Know the differences between.py and.pyc files
- Explore the different ways to install and upgrade Python packages
- Understand the working of the PyPI module that enhances built-in decorators
- See how coroutines are different from generators and how they can simulate multithreading
- Grasp how the decimal module improves floating point numbers and their operations
- Standardize sub interpreters to improve concurrency
- Discover Python's built-in docstring analyzer
Who this book is for
Whether you've been working with Python for a few years or you're a seasoned programmer, you'll have a lot of new tricks to walk away with.
Frequently asked questions
Information
Using Python Collections
- Reviewing containers
- Implementing namedtuple
- Implementing deque
- Implementing ChainMap
- Implementing Counters
- Implementing OrderedDict
- Implementing defaultdict
- Implementing UserDict
- Implementing UserList
- Implementing UserString
- Improving Python collections
- Looking at the collections â extended module
Introduction
Reviewing containers
How to do it...
- x in s: This returns true if an item in sequence s is equal to x; otherwise, it returns false
- x not in s: This returns true if no item in sequence s is equal to x; otherwise, it returns false
- s + t: This concatenates sequence s with sequence t (concatenating immutable sequences creates a new object)
- s * n: This adds s to itself n times (items in the sequence are not copied, but referenced multiple times)
- s[i]: This retrieves the ith item in sequence s, with count starting from 0 (negative numbers start counting from the end of the sequence, rather than the beginning)
- s[i:j]: This retrieves a slice of s, from i (inclusive) to j (exclusive)
- s[i:j:k]: This retrieves a slice from s, from i to j, skipping k times
- len(s): This returns the length of s
- min(s): This returns the smallest item in s
- max(s): This returns the largest item in s
- s.index(x[, i[, j]]): This indexes the first instance of x in s; optionally, it returns x at or after index i and (optionally) before index j
- s.count(x): This returns the total count of x instances in s
- s[i] = x: This replaces the object at index position i with object x
- s[i:j] = t: The slice from i (inclusive) to j (exclusive) is replaced with the contents of object t
- del s[i:j]: This deletes the contents of s from indexes i to j
- s[i:j:k] = t: This replaces the slice of i to j (stepping by k) by object t (t must have the same length as s)
- del s[i:j:k]: This deletes elements of the sequence, as determined by the slice indexes and stepping, if present
- s.append(x): This adds x to the end of s
- s.clear(): This deletes all elements from the sequence
- s.copy(): This is used to shallow copy of s
- s.extend(t): This extends s with the contents of t (can also use s += t)
- s *= n: This is used to update s with its contents repeated n times
- s.insert(i, x): This inserts x into s at position i
- s.pop([i]): This is used to extract an item at index i from s, returning it as a result and removing it from s (defaults to removing the last item from s)
- s.remove(x): This is used to delete the first item from s that matches x (throws an exception if x is not present)
- s.reverse(): This is used to reverse s in-place
There's more...
Lists and tuples
- sort(*, [reverse=False, key=None]): This is used to sort a list in-place, using the < comparator. Reverse comparison, that is, high-to-low, can be accomplished by using reverse=True. The optional key argument specifies a function that returns the list, as sorted by the function.
>>> l = [[3, 56], [2, 34], [6, 98], [1, 43]]
>>> l.sort() >>> l [[1, 43], [2, 34], [3, 56], [6, 98]]