Faster, More Scalable Python
No more single-tasking and idle CPUs!
Don’t dabble.
Discover how to use the full suite of modern Python Concurrency APIs in the Python3 Standard Library.
Nothing extra to install.
How much performance are you leaving on the table?
Ready? Choose your package, otherwise read on:
Robert Young
Introducing:
"The Python Concurrency Boxed Set"
This boxed set includes all 7 books covering everything you need to know to get started and get good at Python concurrency.
You will discover 4 concurrency modules:
You will learn how to use the 4 Python concurrency modules in the Python Standard Library:
- The "threading" module for thread-based concurrency
- The "multiprocessing" module for process-based concurrency
- The "asyncio" module for coroutine-based concurrency
- The "concurrent.futures" module for task executors
You will discover 4 pools of reusable workers:
You will also learn how to use the 4 Python concurrency classes that provide pools of reusable workers:
- The "ThreadPool" class for concurrent loops.
- The "Pool" class for parallel loops.
- The "ThreadPoolExecutor" for modern thread pools
- The "ProcessPoolExecutor" class for modern process pools.
You Get All 7 Books:
The books in the boxed set are:
Book 1: Python Threading Jump-Start
"Python Threading Jump-Start" will teach you how to develop multithreaded programs with the threading module in Python, from scratch.
- Lesson 01: Thread-Based Concurrency
- Lesson 02: Create and Start New Threads
- Lesson 03: Configuring and Interacting with Threads
- Lesson 04: Synchronize and Coordinate Threads
- Lesson 05: Share Data Between Threads
- Lesson 06: Run Tasks with Reusable Workers in Thread Pools
- Lesson 07: Close, Stop, and Kill Threads
Book 2: Python ThreadPool Jump-Start
"Python ThreadPool Jump-Start" will teach you how to develop concurrent loops with the ThreadPool class in Python, from scratch.
- Lesson 01: Threads and Thread Pools
- Lesson 02: Configure the ThreadPool
- Lesson 03: Execute Tasks Concurrently and Wait
- Lesson 04: Execute Tasks Concurrently and Not Wait
- Lesson 05: Execute Tasks Concurrently and Responsive
- Lesson 06: Callbacks and AsyncResults for Async Tasks
- Lesson 07: Case Study Developing a Port Scanner
Book 3: Python ThreadPoolExecutor Jump-Start
"Python ThreadPoolExecutor Jump-Start" will teach you how to develop concurrent loops with the modern ThreadPoolExecutor class in Python, from scratch.
- Lesson 01: Threads, Executors, and Thread Pools
- Lesson 02: Configure the ThreadPoolExecutor
- Lesson 03: Execute Multiple Tasks Concurrently
- Lesson 04: Execute One-Off Tasks Asynchronously
- Lesson 05: Query Asynchronous Tasks
- Lesson 06: Manage Collections of Asynchronous Tasks
- Lesson 07: Case Study Checking the Status of Websites
Book 4: Python Multiprocessing Jump-Start
"Python Multiprocessing Jump-Start" will teach you how to develop parallel programs with the multiprocessing module in Python, from scratch.
- Lesson 01: Process-Based Concurrency
- Lesson 02: Create and Start Child Processes
- Lesson 03: Configuring and Interacting with Processes
- Lesson 04: Synchronize and Coordinate Processes
- Lesson 05: Share Data Between Processes
- Lesson 06: Run Tasks with Reusable Workers in Pools
- Lesson 07: Share Centralized Objects with Managers
Book 5: Python Multiprocessing Pool Jump-Start
"Python Multiprocessing Pool Jump-Start" will teach you how to develop parallel loops with the Pool class in Python, from scratch.
- Lesson 01: Processes and Multiprocessing Pools
- Lesson 02: Configure the Multiprocessing Pool
- Lesson 03: Execute Tasks in Parallel and Wait
- Lesson 04: Execute Tasks in Parallel and Not Wait
- Lesson 05: Execute Tasks in Parallel and Be More Responsive
- Lesson 06: Callbacks and AsyncResults for Asynchronous Tasks
- Lesson 07: Case Study: Parallel Primality Testing
Book 6: Python ProcessPoolExecutor Jump-Start
"Python ProcessPoolExecutor Jump-Start" will teach you how to develop parallel loops with the ProcessPoolExecutor class in Python, from scratch.
- Lesson 01: Processes, Executors, and Process Pools
- Lesson 02: Configure the ProcessPoolExecutor
- Lesson 03: Execute Multiple Tasks Concurrently
- Lesson 04: Execute One-Off Tasks Asynchronously
- Lesson 05: Query Asynchronous Tasks
- Lesson 06: Manage Collections of Asynchronous Tasks
- Lesson 07: Case Study Calculate Fibonacci Numbers
Book 7: Python Asyncio Jump-Start
"Python Asyncio Jump-Start" will teach you how to develop asynchronous programs with the asyncio module and coroutines in Python, from scratch.
- Lesson 01: Asyncio Concurrency
- Lesson 02: Coroutines and Tasks
- Lesson 03: Collections of Tasks
- Lesson 04: Iterators, Generators, and Context Managers
- Lesson 05: Queues and Synchronization Primitives
- Lesson 06: Subprocesses and Streams
- Lesson 07: Port Scanner Case Study
You will save MONTHS of time:
You don't need to read the terse API docs and try to figure out what each function does and when you should use it (which will take you months).
I've done this for you.
- Learn using working code examples, not dry descriptions.
- Use code snippets directly into your projects.
- All code examples are fresh and updated for Python 3.11 and Python 3.12.
You will get FREE lifetime updates:
You will get FREE lifetime updates on the books in the boxed set. Email me any time to get the latest version of any book.
Mišel Sabo
I succeed to faster my code using of Process pool 2.3 times. After some additional optimization I have succeed to speed up to 10 times.
Choose Your Package:
It's time to finally learn Python concurrency systematically.
BOXED SET
TOP SELLER
You get the Boxed Set (7 books)
Including:
- Threading Jump-Start
- Multiprocessing Jump-Start
- Asyncio Jump-Start
- ThreadPool Jump-Start
- Pool Jump-Start
- ThreadPoolExecutor Jump-Start
- ProcessPoolExecutor Jump-Start
All books are provided in PDF and EPUB formats.
Includes all sample Python code files and templates.
Email the author any time if you have questions.
(that is a 9.52% discount)
Can't decide between the packages?
Buy the Boxed Set and upgrade to the Bookshelf later. When you're ready, email me and I'll create an upgrade voucher for you.
BOOKSHELF
BEST VALUE
You get everything (15+ books)
Including the Boxed Set (7 books):
- Threading Jump-Start
- Multiprocessing Jump-Start
- Asyncio Jump-Start
- ThreadPool Jump-Start
- Pool Jump-Start
- ThreadPoolExecutor Jump-Start
- ProcessPoolExecutor Jump-Start
You also get the Interview Q&A Boxed Set (4 books):
- Threading Interview Questions
- Multiprocessing Interview Questions
- Asyncio Interview Questions
- Executors Interview Questions
You also get the By Examples Boxed Set (3 books):
- Concurrent File I/O
- Concurrent NumPy
- Python Benchmarking
You also get the Mastery Boxed Set (1 book):
You also get bonus mindmaps, cheat sheets, and guide:
- Concurrent For Loops Guide
- API Mind Maps (4)
- API Cheat Sheets (7)
All books are provided in PDF and EPUB formats.
Includes all sample Python code files and templates.
Incredible Value!
No one offers anything like this.
All prices are in USD.
(also, you can purchase the boxed set from Amazon and GumRoad)
See What Customers Are Saying:
Lars Klemstein
A really good introduction to Python parallel processing on the right technical level.
Richard Palladino
The SuperFastPython series was exactly what I needed. The information was concise. I was able to understand things much quicker than any other lesson, tutorial, or resource I’d used before. I worked through a lot of the problems I had in the past with my particular use-case and also discovered some things just weren’t possible unless I wanted to recode the dependencies.
I was able to test it and double my speed compared to the BEST results of my past concurrency and async approaches.
Anthony Wilson
Clear. Insightful. Helped me develop from scratch a fully async system used in production
Greatly eases the learning curve for multitasking in Python
ASYNCIO is one Python subsystem for simple multitasking. I wouldn’t classify this library as fully mature and I was struggling greatly to absorb the concepts behind the function calls. I also found it difficult to get the function call syntax right without a bunch of trial-an-error.
I realized that at some point I would need to move some of my tasks to different multi-tasking subsystems. I’d been using the author’s web site for help and discovered the book set. It has provided me with both perspective and practical application of ASYNCIO.
If you don’t have a lot of time to waste learning about this topic and you aren’t into pain, I’d recommend the book set. Well worth the money for me.
Really good!
The whole series of books from Jason is really good. All concepts are well explained, he goes in-depth with clear examples.
Robert Young
Mišel Sabo
I succeed to faster my code using of Process pool 2.3 times. After some additional optimization I have succeed to speed up to 10 times.
Tomex Iskandar
100% Money-Back Guarantee
(no questions asked)
I want you to actually learn Python Concurrency so well that you can confidently use it on current and future projects.
I designed my books to read just like I'm sitting beside you, showing you how.
I want you to be happy. I want you to win!
I stand behind all of my materials. I know they get results and I'm proud of them.
Nevertheless, if you decide that my books are not a good fit for you, I'll understand.
I offer a 100% money-back guarantee, no questions asked.
To get a refund, contact me with your purchase name and email address.
Boxed Set Book Covers
Frequently Asked Questions
This section covers some frequently asked questions.
If you have any questions, contact me directly. Any time about anything. I will do my best to help.
What are your prerequisites?
These books are designed for Python developers who want to discover how to use and get the most out of Python concurrency.
Specifically, the books are for:
- Developers that can write simple Python programs.
- Developers that need better performance from current or future Python programs.
- Developers that want to learn concurrent programming in Python.
These books do not require that you are an expert in the Python programming language or concurrency.
Specifically:
- You do not need to be an expert Python developer.
- You do not need to be an expert in concurrency.
What version of Python do you need?
All code examples use Python 3.
I recommend the latest version of Python, if possible.
Although, most examples will work with Python 3.10+.
Python 2.7 is not supported because it reached its "end of life" in 2020.
Are there code examples?
Yes.
Each lesson has one or more complete, standalone, and fully working code examples.
Each book is provided in a .zip file that includes a src/ directory containing all source code files used in the book.
How long will each book take you to finish?
About 1 hour per lesson.
Work at your own pace.
I recommend 1 lesson per day, over 7 days (1 week) per book.
There's no rush and I recommend that you take your time.
Each book is designed to be read linearly from start to finish, guiding you from being a Python developer at the start of the book to being a Python developer that can confidently use the techniques in your projects by the end of the book.
In order to avoid overload, I recommend completing one lesson per day, such as in the evening or during your lunch break. This will allow you to complete the transformation in about one week.
I recommend you maintain a directory with all of the code you type from the lessons in the book. This will allow you to use the directory as your own private code library, allowing you to copy-paste code into your projects in the future.
I recommend trying to adapt and extend the examples in the lessons. Play with them. Break them. This will help you learn more about how the API works and why we follow specific usage patterns.
What format are the books?
You can read the books on your screen, next to your editor.
You can also read the books on your tablet, away from your workstation.
The books are provided in 2 formats:
- PDF (.pdf): perfect for reading on the screen or tablet.
- EPUB (.epub): perfect for reading on a tablet with a Kindle or iBooks app.
Many developers like to read technical books on their tablet or iPad.
How can you get more help?
The lessons in the books were designed to be easy to read and follow.
Nevertheless, sometimes we need a little extra help.
A list of further reading resources is provided at the end of each lesson. These can be helpful if you are interested in learning more about the topic covered, such as fine-grained details of the standard library and API functions used.
The conclusions at the end of each book provide a complete list of websites and books that can help if you want to learn more about Python concurrency and the relevant parts of the Python standard library. It also lists places where you can go online and ask questions about Python concurrency.
Finally, if you ever have questions about the lessons or code in these books, you can contact me any time and I will do my best to help. My contact details are provided at the end of each book.
Can you print the books?
Yes.
Although, I think it's better to work through the books on the screen.
- You can search, skip, and jump around really fast.
- You can copy and paste code examples.
- You can compare code output directly.
Is there digital rights management?
No.
The ebooks have no DRM.
Do You Get Free Updates To The Books?
Yes.
I update the books all the time to fix typos and to keep the examples up to date with any changes to the APIs.
You can email me any time and I will send you the latest version of any book in your bundle.
Note that you will not get free access to new books released in the future (e.g. new versions of this bundle that include additional books), although as a bundle customer, you will get early access to any new books at a discount.
Can you buy the books elsewhere?
Yes!
You can get a Kindle boxed set from Amazon:
Many developers prefer to buy from the Kindle store on Amazon directly.
Does Python concurrency work on your operating system?
Yes.
Python concurrency is built into the Python programming language and works equally well on:
- Windows
- macOS
- Linux
Does Python concurrency work on your hardware?
Yes.
Python concurrency is agnostic to the underlying CPU hardware.
If you are running Python on a modern computer, then you will have support for concurrency, e.g. Intel, AMD, ARM, and Apple Silicon CPUs are supported.
Where can you learn more about the content of each book?
You can learn more about all of these books here:
How do the "Jump-Start Books" compare to the "Complete Guides"?
The SuperFastPython Jump-Start books are laser-focused on making you productive with a Python concurrency module or class as fast as possible.
This means that many broader topics are not covered because they are not on the critical path.
The guides on SuperFastPython.com are broader in scope and compare the class or module to related modules, describing best practices, common errors, common usage questions, and common objects.
This material may be interesting but is a distraction when you are focused on getting productive as fast as possible.
Another important difference is that the jump-start books are provided in book form, whereas the guides are very long web pages.
This makes the books easy to read on a kindle, tablet, or paperback, as well as the screen, whereas the guides must be read in the browser.
About the Author
Hi, I'm Jason Brownlee, Ph.D.
I'm a Python developer, husband, and father to two boys.
I want to share something with you.
I am obsessed with Python concurrency, but I wasn't always this way.
My background is in Artificial Intelligence and I have a few fancy degrees and past job titles to prove it.
You can see my LinkedIn profile here:
- Jason Brownlee LinkedIn Profile
(follow me if you like)
So what?
Well, AI and machine learning has been hot for the last decade. I have spent that time as a Python machine learning developer:
- Working on a range of predictive modeling projects.
- Writing more than 1,000+ tutorials.
- Authoring over 20+ books.
There's one thing about machine learning in Python, your code must be fast.
Really fast.
Modeling code is already generally fast, built on top of C and Fortran code libraries.
But you know how it is on real projects…
You always have to glue bits together, wrap the fast code and run it many times, and so on.
Making code run fast requires Python concurrency and I have spent most of the last decade using all the different types of Python concurrency available.
Including threading, multiprocessing, asyncio, and the suite of popular libraries.
I know my way around Python concurrency and I am deeply frustrated at the bad wrap it has.
This is why I started SuperFastPython.com where you can find hundreds of free tutorials on Python concurrency.
And this is why I wrote these books.
Praise for Super Fast Python
Python developers write to me all the time and let me know how helpful my tutorials and books have been.
Below are some select examples posted to LinkedIn.
What Are You Waiting For?
Stop reading outdated StackOverflow answers.
Learn Python concurrency correctly, step-by-step.
Start today.
Buy now and get your copy in seconds!