Managing Python Dependencies with Pip and Virtual Environments: The Complete Course
Click here to save 20% (and get extra bonuses)
Hey Reader,
Back when I got "serious" about building my Python skills, mastering the syntax of the language wasn't the challenge that held me back.
Python’s syntax seemed quite clear and intuitive by comparison, and I saw a (relatively) obvious path to learning it.
But when it came to Python’s 100k+ libraries and frameworks—
That was simply an OVERWHELMING amount of information to absorb and digest.
Even when I knew there had to be a library out there that already solved a problem I was facing—I drew a blank when it came to researching it.
I didn’t know what made a Python library or framework worthwhile.
Everything blended together into a "sea of modules" and I couldn’t winnow out the useless or obsolete—
In short, I was lost when it came to finding and judging the quality of Python libraries.
And so I spun my wheels…
You see, what tripped me up as a fledgling Pythonista was this:
I had the basics of Python under my belt, but—
I struggled when it came to adopting the right workflows and tools of the "ecosystem" surrounding the core language
Thus, I wasted my time reinventing existing solutions left and right.
Sometimes I spent DAYS writing my own (terrible) versions of common building blocks like timestamp parsers, or web scrapers.
Now, sure I learned quite a bit from doing that…
But I kept repeating the same mistake and was "reinventing the wheel" even when under a tight deadline. (The irony!)
In hindsight, my ignorance caused me a ton of undue stress and sleepless nights.
Part of it was overconfidence in my abilities—and another part was that I lacked experience using "bread and butter" tools like the pip package manager, virtual environments, and requirements files.
And it prevented me from breaking through to the next phase of developing code in Python.
You see, languages such as C++ that I used before didn’t have an advanced package management system like Python.
Because I was used to "copy-pasting" third-party code into my own projects I missed out on the versioning features in Python packages.
And instead of building applications that combined the power of several specialized building blocks—
I strung together messy "copypasta" globs of code that I couldn’t get to run on anyone else’s computer.
Today I know I’m not the only developer who had to overcome "reinventing the wheel disease."
Tragically, it is a hidden roadblock to many aspiring Pythonistas:
What separates experienced Python programmers from learners is that they create new functionality with building blocks they already know.
And leveraging these building blocks requires a vast set of inter-related pieces of knowledge—from packages to deployment:
Now, most "stuck" Python developers are aware of the tools that could help them ascend from "dependency hell"—
But they don’t see how to use them to their advantage.
If you ask a group of junior or intermediate Python developers about their experience you’ll hear things like:
"I’ve heard people say ‘you should always use a virtualenv’ but I don’t really see why. Seems like an additional step I don’t really need…"
You know, the problem is that:
Too many Python developers know these tools exist, but they don’t see why they’re important and what makes them so powerful.
And tragically, by ignoring the help that tools like pip, virtualenv, and PyPI provide these developers sabotage their own productivity.
So ask yourself this:
If you use Python and you’re wondering how to go from "writing scripts" to "building applications"—
Then there’s a good chance that missing Dependency Management skills are holding you back from your full potential as a Python developer.
If you can fill in those gaps in your knowledge your productivity and efficiency as a Python developer will benefit greatly.
That’s what happened to me—
Once I got the hang of Python’s dependency management tools and workflows I was quickly able to shake off my "reinventing the wheel disease."
I can see now how removing this roadblock triggered a "quantum leap" in my productivity as a software developer.
Here’s the secret:
By leveraging Python’s packaging ecosystem you will be coding at a higher level of abstraction—
Instead of wasting time re-coding tools and functionality that already existed, I was able focus on the business goals.
Figuring this out had a MASSIVE impact on my productivity and efficiency as a Python developer.
Saying it allowed me to "10X" my output wouldn’t be too far off.
Within a month my peers and superiors had noticed my improved productivity—because they saw me tearing through sprint tickets left and right.
It’s one of the easiest and quickest "wins" you can get in your Python career.
I’ve seen it happen several times with 1:1 coaching clients and during workshops.
But this kind of training can only reach so many people.
And I wanted every Python developer to be able to take advantage of modern dependency management workflows and tools.
So I got to work…
And now, after months of recording and editing I’m proud to introduce my new "Managing Python Dependencies" course.
It is an organized, step-by-step system for mastering the tools and workflows that will help you reach the next level of productivity as a Python developer.
It consists of 32 bite-sized lessons, each focusing on a single concept.
Progressing through the course, you’ll quickly build up a comprehensive knowledge of dependency management best practices in Python at your own, comfortable pace.
Along the way, you’ll see hands on examples and step-by-step workflows that reinforce the skills you’re learning.
By the end, you’ll know how to apply Python’s recommended dependency management tools effectively and to your advantage in most day-to-day development scenarios.
With Managing Python Dependencies you will:
Code at a higher level and become more efficient: Leveraging Python’s rich third-party library ecosystem let's you write better programs in a shorter amount of time. With a large body of freely available modules you can avoid reinventing the wheel and deliver higher quality Python software, faster. This is a great way for you to demonstrate senior level skills that will benefit your development career.
Get up to speed with Python dependency management quickly: Your time is your most important asset. If you can use it efficiently you will save your sanity—and a nice stack of money. This course is concise but thorough and will help you attain solid Python dependency management knowledge fast.
Go from "writing scripts" to "building applications" with Python: By taking advantage of Python’s rich packaging ecosystem you’ll be able to build substantial and full-featured applications in Python. You’ll know the best practices for finding and documenting application dependencies that put you right on track for deploying and shipping production-grade apps.
Find great libraries for a specific task at hand: This course teaches you a convenient 7-step workflow for finding and identifying quality Python packages. Know which libraries and tools are available on PyPI to help you. By quickly and easily finding the correct libraries you’ll speed up your development efficiency by a large margin. Meet your deadlines and write better code at the same time by not having to "reinvent the wheel."
Master "the tools of the trade" for dependency management: With this course you'll master the tools and workflows recommended by the official Python Packaging Authority. By getting those skills under your belt you’ll be ready to work with the Python development and production environments used by professional development teams across the world. Knowing these "tools of the trade" by heart puts you at an advantage in any job interview situation.
"Productionize" your Python projects and share them with the world: You’ll see how to apply the best practices for defining and installing package dependencies in Python. This allows you to publish your programs to production environments and makes it easy for other developers to contribute with minimal setup effort.
Become an expert at finding and identifying quality Python libraries: With my detailed 7-step workflow for researching quality Python packages you’ll know how to document and justify added program dependencies to your team and your manager. By taking on more responsibilities and picking up these senior-level "architectural" skills you’ll rise head and shoulders above other devs stuck at the "code monkey" level.
So how does the course work?
Managing Python Dependencies will give you the tools and best practices to tackle Python application development with confidence.
Here’s a breakdown of the course contents:
Module 1 – Welcome & Course Overview: You'll get a quick overview of the course and a rundown of the course curriculum. This helps prepare your "mental map" of what you're going to learn in the course so you can retain that knowledge more readily.
Module 2 – Managing Third-Party Dependencies With Pip: Discover how dependency management enables modern software development by making well-packaged building blocks available in your own programs. You'll start with an introduction to dependency management in Python, including its main benefits and challenges. Then you'll get hands-on examples for how to work with "pip", the official Python package manager. You'll learn how to install and update pip, how it's command line interface works, and how you can use pip to install (and uninstall) third-party packages. You'll also see how to identify and selectively upgrade outdated dependencies. Besides that you'll gain a deep understanding of Python's packaging ecosystem, including the main package repositories like PyPI and Warehouse, as well as advanced version management features in pip.
Module 3 – Isolating Dependencies With Virtual Environments: In this module you'll discover how leveraging sandboxed Python environments helps you avoid version conflicts and deployment headaches. By following along with hands-on live demos you'll see how to smoothly integrate virtual environments into your Python (2.x or 3.x) development workflow. I'm also sharing my personal command-line workflow and shell setup for making switching between virtual environments a breeze.
Module 4 – Finding Quality Python Packages: In this core module in the course you'll master how to find and identify quality Python packages. You'll see how the more than 100,000 third-party packages available today will help you save time, avoid "reinventing the wheel", and deliver your projects faster. After that you'll see how to use curated lists for finding and picking the best Python packages for most common scenarios. Next, you'll pick up a unique 7-step workflow for finding and selecting quality Python packages. This module is chock-full with hands-on examples and in-depth discussions of how to find and select the ideal Python library for any use case. You'll see exactly how I avoid low-quality packages in order to keep maintenance costs low and development headache-free. Besides that, you'll see how you can use the same process to justify and defend dependency decisions to your team or manager.
Module 5 – Setting Up Reproducible Environments & Application Deploys: See how to leverage "requirements files" and specific workflows to allow your Python programs to run flawlessly and with the exact same set of dependencies on local development environments, automated test or build servers (CI), as well as staging and production deployment targets. By mastering these workflows and making your dependency installs 100% repeatable you'll save time and reduce development delays for yourself and everyone you work with. In this module you'll also see the habits and processes I use to structure my Python source code repositories in order to simplify dependency installs and make them more convenient.
Module 6 – Course Conclusion and Recap: The course ends with a "lightning review" of the main concepts you picked up. This helps reinforce your learning and enables you to apply your favorite "tricks" and workflows from the course right away.
To help you deepen your mastery of dependency management tools and best practices in Python, I have put together several additional bonuses that perfectly complement this course.
Managing Python Dependencies is your "one-stop shop" for learning how to use modern dependency management practices and workflows with minimal time investment.
Take advantage of these additional bonuses included with the course to speed up your learning progress:
Bonus #1 – Word-for-Word Transcripts & Subtitles (All 32 Videos)
This package includes full, human-made transcripts and subtitles for all lessons in the course. With these transcripts following the course lessons will be a breeze even if English is not your native language.
Bonus #2 – "Review at Your Own Pace" PDF Slides for All Course Lessons
These uncut (and fully searchable) PDF slides are perfect to keep handy as a quick reference when you want to refresh your memory about Python dependency management without scrobbling through the videos.
Bonus #3 – "Track Your Learning Progress" Course Workbook
Use this printable 28-page PDF workbook to track your learning progress as you make your way through the course. Each page in the workbook is dedicated to a single lesson in the course. You can mark lessons and modules as completed and take your learning notes in the blank space on each page. This will help you build up your mental "knowledge map" of the topic and reinforce your learning.
Bonus #4 – Audio-Only MP3 Version of the Full Course
The course package includes a full audio-only version of the course contents as a bonus. If you’re strapped for time you can listen to the whole course while you’re commuting or working.
To recap what's "in the box":
- 32 HD-quality video lessons ($396)
- Word-for-Word transcripts for all course lessons ($161)
- 190+ "Review at Your Own Pace" PDF slides ($29)
- "Track Your Learning Progress" Course Workbook ($14)
- DRM-free MP3 audio-only version of the course ($57)
- Lifetime access to the course (stream & DRM-free download)
In total the complete course package contains $657 worth of Python training.
It’s a "one-stop shop" for the dependency management skills and best practices that professional Python engineers are expected to know today.
With this course you’re making the smartest kind of investment there is—an investment in yourself and your own abilities as a developer.
And an investment like this could easily pay you back 50X or 100X in the next year.
That might sound over the top, but it’s actually pretty realistic.
Think about it…
The workflows and best practices you’ll get from this course are "table stakes" for senior-level Python development jobs.
Dependency management and application deployment is one of those "icky" but important topics that’s often overlooked by inexperienced developers.
With your newfound skill set you’ll be able to demonstrate that you care about *shipping* a quality product and not "just coding" it.
You’ll be able to help your colleagues with your expertise. Teaching your coworkers new tricks and workflows that make them more productive is the best way to get recognized as an expert.
Pulling everyone else around you UP and making them more productive is a fantastic way to show you’re ready to take on more responsibility—which in turn is one of the best ways to get yourself promoted.
Here’s the kicker:
Even though the "return on investment" for this course is excellent, I wanted it to price it so it is affordable for *all* Pythonistas in my audience.
Which I why I’ve decided to make the complete course, including all bonuses, available for an additional 20% off the regular price.
You'll have to act quickly though—this discount is only available for the next 2 days.
So click the link below now and claim your 20% discount:
>> Managing Python Dependencies: The Complete Course
— Dan Bader