Managing Python Dependencies Transcripts
Chapter: Managing Third-Party Dependencies With pip
Lecture: Installing Packages With pip
0:01 Next, you'll learn how to install packages with pip.
0:04 We're going to cover the different ways you can install packages from PyPi,
0:08 how you can install packages from other sources,
0:12 like git and other version control mechanisms,
0:15 how you can update packages and how you can uninstall them again.
0:19 This is how you install packages with the pip command line tool.
0:23 Basically, you open a terminal, and you run the pip install command,
0:27 passing it the name of the package that you want to install.
0:31 And by default, this is going to install packages from the PyPi package repository.
0:35 Pip also caches packages locally, to speed up repeated installs.
0:41 Let's take a look at a quick demo here.
0:44 I am in a new terminal session here, and now I am going to walk you
0:47 through how to install a Python package using the pip install command line.
0:52 So, the pip command line interface has a couple of useful commands,
0:56 for example, there is the pip list command, that I can use to inspect
0:59 which packages are installed at the moment, so let's run this.
1:03 So this lists all of the packages that are installed
1:06 into my global Python environment right now, this is a really base line setup
1:10 and it doesn't really include anything besides pip and its dependencies,
1:14 what I am going to do now is install a third party package,
1:18 and for that we're going to use the Requests module.
1:21 So when you look at this list, you can see that it definitely
1:24 does not include Requests right now, so let's change that.
1:28 So this is the pip install command to install the Requests library, let's run it now.
1:33 Alright, so the installation completed successfully,
1:38 and now when I run the pip list command again,
1:42 Request should show up in that list.
1:45 Yeah, here it is, we successfully installed Requests.
1:48 Let's try it out, so I am going to jump into a Python interpreter session now,
1:51 and I am going to try and import the Requests module that we just installed,
1:59 alright, this succeeded, yeah, that looks pretty good,
2:05 let's try and actually fire off a real HTTP request.
2:18 Perfect, that worked just fine.
2:23 Another handy command is pip show,
2:26 you can use it to display metadata and information about locally installed packages,
2:31 so I am going to go ahead and run that on Requests now.
2:35 So you can see here, for example, the name and the version
2:39 of the library that was installed, a quick summary, the homepage for the library,
2:43 the license and also where it was installed locally on my machine.
2:47 So you just saw how to install a package from PyPi using the pip install command,
2:52 now what this will do is it will always install the latest version of the package
2:57 that is currently available, so what do you do if you want to install
3:00 an older, or a specific version of a package instead?
3:03 Pip has you covered there.
3:06 You can actually pass so called version specifiers to package names
3:09 when you install them through pip install,
3:12 with this pip install requests==2.1.3 command,
3:16 I am installing a specific version of Requests
3:20 and these version specifiers can get pretty flexible,
3:22 for example, I can do this and actually pass
3:26 a version range for this Requests module,
3:29 so in this case, I would tell pip to install a version of Requests
3:33 that is between version 2.0 and 3.0, so essentially,
3:38 I would tell pip to install the latest version in the version 2 series of Requests.
3:44 One more feature when it comes to version specifiers, is the ~=specifier.
3:50 This tells pip to install a version of Requests that is compatible with version 2.1.3
3:56 in practical terms, that means it's going to try and install a version of the 2.1 branch
4:04 of Requests, that is going to be at least version 2.1.3,
4:10 so 2.1.4 and 2.1.5 and so on, would all be candidates for this.
4:16 Now this is handy for example if you want to get minor version updates automatically,
4:20 but you still want to retain some control over larger upgrades,
4:24 if you're using version specifiers, I would generally recommend
4:28 that you are very specific with them because this can help avoid surprises.
4:32 Later on in this course, we're going to come back to these version specifiers,
4:35 and you're going to learn how to use them to set up fully reproducible
4:39 Python environments for your applications.
4:42 Before you move on, here is a quick warning about
4:45 installing packages globally using pip.
4:48 When you use the pip install command, by default,
4:51 it will install Python packages into the global Python environment.
4:55 This means that any package you install this way is going to be shared
5:00 across the whole system or across your whole user account,
5:03 now this might be completely okay, if it's done intentionally,
5:07 for example, in order to install Python based command line tools,
5:11 like httpy in this case, you probably want to make sure
5:15 that you can access the tool from anywhere in the system.
5:19 Most of the time you should prefer so called virtual environments,
5:23 they are a way to keep your Python packages nice and separate by project,
5:27 and that way you can make sure you're not cluttering up the global environment,
5:31 later on in this course, you are going to learn
5:33 how to set up and use virtual environments,
5:37 this will help you avoid version conflicts
5:39 and we'll make sure that each project you're working on
5:42 has its own Python environment, to install packages into.
5:45 Here is another useful feature for installing packages with pip.
5:50 You just learned how you can install packages from a package repository like PyPi,
5:55 but pip also supports other sources, for example,
6:00 you can install packages directly from git and other version control systems,
6:04 here is what this would look like for installing a package that is hosted on GitHub,
6:09 you would pass a url pointing to a git repository to the pip install command.
6:14 And you can even control which branch
6:17 or a specific commit in that repository you want to install.
6:20 Here are a few examples that install the Requests library directly from GitHub.
6:26 In the first example, I am putting the at master specifier,
6:31 to install the latest version of Requests directly from its master branch on git.
6:37 In the second example, I am using a commit hash specifier
6:41 to install a very specific version of the Requests library.
6:45 In the third example, I am pointing pip at a specific git tag to install Requests from.
6:52 You can see here how this gives you a lot of flexibility,
6:55 you might use this functionality to install a very specific versions of a library,
7:00 for example, if you're waiting for a bug fix to land in the official release,
7:05 and you really can't afford to wait so sometimes maybe you want to install
7:09 the latest version of a library, directly from its source repository.
7:13 or, you could use this feature to install private packages and libraries
7:19 that are not available on PyPi. So you would just host your own library
7:24 in a git repository somewhere, and then point pip towards that.
7:29 generally though, if you can install a package
7:31 from a proper package repository like PyPi, then I would definitely do it.
7:36 Installing a Python package directly from
7:39 a version control system is a bit of a special case.
7:42 Typically, you wouldn't use that functionality
7:46 to install any old publicly available package,
7:49 but you would reserve it for those special moments
7:52 when you really need to be on the cutting edge
7:54 and maybe need to install a specific commit
7:56 of a package to get your program to work.
7:59 This is definitely useful but I would also handle it with care,
8:02 and stick to PyPi when possible.