How to Install Python 3 on Linux. Guide to Installing and Configuring Python Correctly

Daniel Morales
Mar 28, 2020

Contents Outline

How to Install Python 3 on Linux. Guide to Installing and Configuring Python Correctly

Mar 28, 2020 7 minutes read

Most likely your current Linux distribution already has Python installed, but you probably don't have the latest version, or at least version 3. To see if your operating system is installed and to find out the current version, just type the following code in your command line:

python --version
You probably have version 2, let's check if you have version 3 installed:

python3 --version
If version 3 appears, you have it installed and updated. 

If you get version 2, or a version less than 3.6.5 (at this time), it's a good idea to install the latest version. To do this, it depends on the Linux distribution you have installed on your computer.

Ubuntu

Depending on the Ubuntu distribution you are running on your machine, the instructions vary. You can determine which version of Ubuntu you have with the following command:

➜  ~ lsb_release -a 
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 16.04.5 LTS
Release:	16.04
Codename:	xenial
Depending on the version number under Release on the console output, continue with these instructions

  • Ubuntu 17.10, Ubuntu 18.04 (and higher) come with Python 3.6 by default. You should be able to call it with the python3 command.
  • Ubuntu 16.10 and 17.04 don't come with Python 3.6 by default, but it's in the universal repository. You should be able to install it with the following commands:
    • $ sudo apt-get update
$ sudo apt-get install python3.6
    • you can then call it with the python3.6 command.
  • If you are using Ubuntu 14.04 or 16.04, Python 3.6 is not in the universal repository, you will need to get it from a Personal Packages File (PPA). For example, to install Python from the PPA "deadsnakes", do the following:
    • $ sudo add-apt-repository ppa:deadsnakes/ppa
$ sudo apt-get update
$ sudo apt-get install python3.6
    • As in the previous case, call it with the command python3.6.
Linux Mint
Mint and Ubuntu use the same package management system, which often makes our lives easier. You can follow the instructions above for Ubuntu 14.04. The PPA "deadsnakes" works with Mint.

CentOS
The IUS community does a good job of providing new software releases for "Enterprise Linux" distributions (i.e. Red Hat Enterprise and CentOS). You can use their work to help you install Python 3

To install, you should first update your system with the yum package manager:

$ sudo yum update
$ sudo yum install yum-utils
then you can install the CentOS IUS package that will bring you up to date with your site:

$ sudo yum install https://centos7.iuscommunity.org/ius-release.rpm
Finally you can install Python and Pip:

$ sudo yum install python36u
$ sudo yum install python36u-pip
Debian
There are sources that say that the Ubuntu 16.10 method works the same for Debian, but it often causes failures in Debian 9.

One problem with Debian, however, is that it generally does not install the sudo command by default. To install it, you will need to do the following before carrying out the Python compile-time instructions below:

$ su
$ apt-get install sudo
$ vi /etc/sudoers
After that, open the file /etc/sudoers using the command sudo vim (or your favorite text editor.) Add the following line of text at the end of the file, replacing your_username with your real username:

your_username ALL=(ALL) ALL
Fedora
Fedora has a roadmap for switching to Python 3 as the default Python. So the current version and future versions will be delivered with Python 2 as default, but Python 3 will be installed. If the python3 installed in your version is not 3.6, you can use the following command to install it

$ sudo dnf install python36
openSUSE
Doing this installation by means of zypper is somewhat problematic and may not work properly. It is a better idea to build the Python code from source. To do this, it is necessary to install the development tools, which can be done in YaST (through the menus) or using zypper:

sudu zypper install -t pattern devel_C_C++
This step will take some time and involves the installation of 154 packages, but once it is complete, you will be able to build the source code as shown in the Compiling Python from Source section below.

Arch Linux
Arch Linux is quite aggressive in keeping up with Python versions. You probably already have the latest version. If not, you can use this command:

$ packman -S python

Compiling Python from source
To start, you need to get the Python source code. Python.org makes it pretty easy. If you go to the download page, you'll see the latest Python 3 source code at the top. (Be sure not to take the Legacy Python, Python 2).

When you select the version, at the bottom of the page there is a Files section. For example for the latest version 3.8 you can see it here: https://www.python.org/downloads/release/python-381/.  Select the compressed source tarball and download it to your machine. If you prefer a command line method, you can easily use wget to download it to your current directory:

$ wget https://www.python.org/ftp/python/3.6.5/Python-3.6.5.tgz
Step 2: Prepare your system
There are a few distribution-specific steps needed to build Python from scratch. The goal of each step is the same in all distributions, but you may have to translate it into your distribution if you don't use apt-get:

The first step you should take when performing an operation like this is to update the system packages on your machine before you start. In Debian, this is what it looks like:

$ sudo apt-get update
$ sudo apt-get upgrade
Next, we want to make sure that the system has the necessary tools to build Python. There are a lot of them and you may already have some, but that's okay. We've listed them all on one command line, but you can split the list into shorter commands by just repeating the sudo apt-get install -y portion:

# For apt-based systems (like Debian, Ubuntu, and Mint)
$ sudo apt-get install -y make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev  libncursesw5-dev xz-utils tk-dev

# For yum-based systems (like CentOS)
$ sudo yum -y groupinstall development
$ sudo yum -y install zlib-devel

Step 3: Build Python
Once you have the prerequisites and the tar file, you can unpack the source code into a directory. Note that the following command will create a new directory called Python-3.6.5 under which you are:

$ tar xvf Python-3.6.5.tgz
$ cd Python-3.6.5
Now you need to run the ./configure tool to prepare the construction:

$ ./configure --enable-optimizations --with-ensurepip=install
Then build the Python programs using make. The -j option simply tells make to split the construction into parallel steps to speed up compilation. Even with parallel constructions, this step can take several minutes:

$ make -j 8
Next, you'll want to install your new version of Python. You will use the altinstall target here so as not to overwrite the Python version of the system. Since you are installing Python in /usr/bin, you will need to run it as root:

$ sudo make altinstall
Warning: Please only use the altinstall target in make. Using the installation target will overwrite the python binary. While this sounds like a great idea, there are large parts of the system that depend on the pre-installed version of Python.

Step 4: Verify the Python Installation
Finally, you can test your new version of Python:

$ python3.6 -V
Conclusion: 

Installing Python 3 on linux is not that difficult, we just have to follow the step by step of each one of the distributions, and with this we will get the power of python on our machine, and we can start making code focused on Data Science and machine Learning!

Related Posts

How to Use Python Datetimes Correctly?

Why Decorators In Python Are Pure Genius?

3 Python Tricks That Will Improve Your Code

Categories

Data Science Machine Learning Deep learning Flask Deployment Big Data Business Python SQL Programming Libraries Jupyter Numpy News Pandas Matplotlib Visualization

Join Competition

Code the Light Fantastic

Google Play Store Rating Prediction

Most Related Articles

Python
Programming
Why Decorators In Python Are Pure Genius?

Analyze, test, and re-use your code with little more than an @ symbolIf there’s one thing that makes Python incredibly successful, that would be its readability. Everything else hinges on that: if code is unreadable, it’s hard to maintain. It’s also not beginner-friendly then — a novice getting boggled by unreadable code won’t attempt writing its own one day.Python was already readable and beginner-friendly before decorators came around. But as the language started getting used for more and more things, Python developers felt the need for more and more features, without cluttering the landscape and making code unreadable.Decorators are a prime-time example of a perfectly implemented feature. It does take a while to wrap your head around, but it’s worth it. As you start using them, you’ll notice how they don’t overcomplicate things and make your code neat and snazzy.Before anything else: higher-order functionsIn a nutshell, decorators are a neat way to handle higher-order functions. So let’s look at those first!Functions returning functionsSay you have one function, greet() — it greets whatever object you pass it. And let’s say you have another function, simon() — it inserts “Simon” wherever appropriate. How can we combine the two? Think about it a minute before you look below.def greet(name): return f"Hello, {name}!" def simon(func): return func("Simon") simon(greet)The output is 'Hello, Simon!'. Hope that makes sense to ya!Of course we could have just called greet("Simon"). However, the whole point is that we might want to put “Simon” into many different functions. And if we don’t use “Simon” but something more complicated, we can save a whole lot of lines of code by packing it into a function like simon().Functions inside other functionsWe can also define functions inside other functions. That’s important because decorators will do that, too! Without decorators it looks like this:def respect(maybe): def congrats(): return "Congrats, bro!" def insult(): return "You're silly!" if maybe == "yes": return congrats else: return insultThe function respect() returns a function; respect("yes") returns the congrats function, respect("brother") (or some other argument instead of "brother") returns the insult function. To call the functions, enter respect("yes")() and respect("brother")(), just like a normal function.Also read: Python Books You Must Read in 2020Got it? Then you’re all set for decorators!Code is beautifully nerdy. Image by author.The ABC of Python decoratorsFunctions with an @ symbolLet’s try a combination of the two previous concepts: a function that takes another function and defines a function. Sounds mind-boggling? Consider this:def startstop(func): def wrapper(): print("Starting...") func() print("Finished!") return wrapper def roll(): print("Rolling on the floor laughing XD") roll = startstop(roll)The last line ensures that we don’t need to call startstop(roll)() anymore; roll() will suffice. Do you know what the output of that call is? Try it yourself if you’re unsure!Now, as a very good alternative, we could insert this right after defining startstop():@startstop def roll(): print("Rolling on the floor laughing XD")This does the same, but glues roll() to startstop() at the onset.Added flexibilityWhy is that useful? Doesn’t that consume exactly as many lines of code as before?In this case, yes. But once you’re dealing with slightly more complicated stuff, it gets really useful. For once, you can move all decorators (i.e. the def startstop() part above) into its own module. That is, you write them into a file called decorators.py and write something like this into your main file:from decorators import startstop @startstop def roll(): print("Rolling on the floor laughing XD")In principle, you can do that without using decorators. But this way it makes life easier because you don’t have to deal with nested functions and endless bracket-counting anymore.You can also nest decorators:from decorators import startstop, exectime @exectime @startstop def roll(): print("Rolling on the floor laughing XD")Note that we haven’t defined exectime() yet, but you’ll see it in the next section. It’s a function that can measure how long a process takes in Python.This nesting would be equivalent to a line like this:roll = exectime(startstop(roll))Bracket counting is starting! Imagine you had five or six of those functions nested inside each other. Wouldn’t the decorator notation be much easier to read than this nested mess?You can even use decorators on functions that accept arguments. Now imagine a few arguments in the line above and your chaos would be complete. Decorators make it neat and tidy.Also read: How to Get a Job With PythonFinally, you can even add arguments to your decorators — like @mydecorator(argument). Yeah, you can do all of this without decorators. But then I wish you a lot of fun understanding your decorator-free code when you re-read it in three weeks…Decorators make everything easier. Image by author.Applications: where decorators cut the creamNow that I’ve hopefully convinced you that decorators make your life three times easier, let’s look at some classic examples where decorators are basically indispensable.Measuring execution timeLet’s say we have a function called waste time() and we want to know how long it takes. Well, just use a decorator!import time def measuretime(func): def wrapper(): starttime = time.perf_counter() func() endtime = time.perf_counter() print(f"Time needed: {endtime - starttime} seconds") return wrapper @measuretime def wastetime(): sum([i**2 for i in range(1000000)]) wastetime()A dozen lines of code and we’re done! Plus, you can use measuretime() on as many functions as you want.Slowing code downSometimes you don’t want to execute code immediately but wait a while. That’s where a slow-down decorator comes in handy:import time def sleep(func): def wrapper(): time.sleep(300) return func() return wrapper @sleep def wakeup(): print("Get up! Your break is over.") wakeup()Calling wakeup() makes lets you take a 5-minute break, after which your console reminds you to get back to work.Also read: Building A Linear Regression Model With Python To Predict Retail Customer SpendingTesting and debuggingSay you have a whole lot of different functions that you call at different stages, and you’re losing the overview over what’s being called when. With a simple decorator for every function definition, you can bring more clarity. Like so:def debug(func): def wrapper(): print(f"Calling {func.__name__}") return wrapper @debug def scare(): print("Boo!") scare()There is an a lot more elaborate example here. Note, though, that to understand that example, you’ll have to check how to decorate functions with arguments. Still, it’s worth the read!Reusing codeThis kinda goes without saying. If you’ve defined a function decorator(), you can just sprinkle @decorator everywhere in your code. To be honest, I don’t think it gets any simpler than that!Handling loginsIf you have functionalities that should only be accessed if a user is logged in, that’s also fairly easy with decorators. I’ll refer you to the full example for reference, but the principle is quite simple: first you define a function like login_required(). Before any function definition that needs logging in, you pop @login_required. Simple enough, I’d say.Syntactic sugar — or why Python is so sweetIt’s not like I’m not critical of Python or not using alternative languages where it’s appropriate. But there’s a big allure to Python: it’s so easy to digest, even when you’re not a computer scientist by training and just want to make things work.If C++ is an orange, then Python is a pineapple: similarly nutritious, but three times sweeter. Decorators are just one factor in the mix.But I hope you’ve come to see why it’s such a big sweet-factor. Syntactic sugar to add some pleasure to your life! Without health risks, except for having your eyes glued on a screen.I wish you lots of sweet code!Also Read: How to Use Python Datetimes Correctly?

Python
SQL
Programming
How to Use Python Datetimes Correctly?

Datetime is basically a python object that represents a point in time, like years, days, seconds, milliseconds. This is very useful to create our programs.The datetime module provides classes to manipulate dates and times in a simple and complex way. While date and time arithmetic is supported, the application focuses on the efficient extraction of attributes for formatting and manipulating output

Python
3 Python Tricks That Will Improve Your Code

I’ve been coding in Python for more than 10 years. There was a time when I thought I knew it all, which was a clear sign I was getting complacent.Then I decided to do a bit of research about Python improvements. Those 3.6, 3.7, 3.8 Python versions aren’t there for nothing, right?After going through release notes, I found these neat tricks that I would like to share with you.By reading this article, you’ll learn:How to format big integers more clearlyA better way to work with file pathsThe proper way of string formating1. Formatting big integersUsing Underscores in Numeric Literals. Image by Roman OracFrom Python 3.6 (and onwards) you can use underscores to make numbers easier to read. See PEP 515 for more details.Let’s look at an example:a = 1000000000 # Is variable a billion or 100 millions? # Let's use underscores to make it easier to read a = 1_000_000_000 # You can group numbers as you like b = 1_0_9_0It also works with hexadecimal addresses and grouping bits.# grouping hexadecimal addresses by words addr = 0xCAFE_F00D # grouping bits into nibbles in a binary literal flags = 0b_0011_1111_0100_1110Also read: Why Decorators In Python Are Pure Genius?2. PathlibPhoto by Alice Donovan Rouse on UnsplashWorking with paths can be challenging especially if your code needs to run on multiple operating systems.Luckily for us, Python standard library has pathllib.Let’s look at an example:from pathlib import Path path = Path("some_folder") print(path) # output: some_folder # We can add more subfolders in a readable way path = path / "sub_folder" / "sub_sub_folder" print(path) # output: some_folder/sub_folder/sub_sub_folder # make path absolute print(path.resolve()) # output: /Users/r.orac/some_folder/sub_folter/sub_sub_folderDespite using / sign as the separator to concatenate paths, pathlib makes it operating system agnostic, meaning it will also work on Windows OS.Also read: Using Python And Pandas Datareader to Analyze Financial Data3. Simplify string formattingf-string formatting in Python. Image by Roman OracI’m used to using old school string formatting in Python:person = 'Roman' exercise = 0 print("%d-times %s exercised during corona epidemic" % (exercise, person)) # output # 0-times Roman exercised during corona epidemicUntil recently, I didn’t know there is a better (more modern) way of string formatting in Python.In Python 3.6, PEP 498 introduces Literal String Interpolation, which simplifies the string formatting.We can rewrite the example above to:person = 'roman' exercise = 0 print(f"{exercise}-times {person} exercised during corona epidemic") # output # 0-times Roman exercised during corona epidemicA string prefixed with f is known as fstring.fstrings even support math operations:print(f"{exercise+1}-times {person} exercised during corona epidemic") # Output # '1-times roman exercised during corona epidemic'But I didn’t exercise during the corona epidemic so adding +1 in the fstring would simply be a lie 😂What about formatting float values?f = 0.333333 print(f"this is f={f:.2f} rounded to 2 decimals") # Output this is f=0.33 rounded to 2 decimalsAlso read: How to Use Python Datetimes Correctly?ConclusionThese Python tricks will make your code more concise and will make coding more enjoyable.Many Python developers don’t know about these tricks — you’re not one of them anymore.Before you goFollow me on Twitter, where I regularly tweet about Data Science and Machine Learning.Also read: Understanding Python's Collections Module

Python
Top 10 Python Extensions for Visual Studio Code

In this new post we want to talk about the most useful Python extensions for Visual Studio Code. Visual Studio Code is an integrated development environment created by Microsoft for Windows, Linux and macOS. Among its features are debugging, syntax highlighting, smart code completion, snippets, code refactoring and integrated Git. Users can change the theme, keyboard shortcuts, preferences and install extensions that add additional functionality.Precisely we are going to talk about the extensions you can install for VS. Here is a list of our favorites1- PythonLink: https://github.com/Microsoft/vscode-pythonPython extension for Visual Studio CodeA Visual Studio Code extension with rich support for the Python language (for all actively supported versions of the language: >=3.6), including features such as IntelliSense (Pylance), linting, debugging, code navigation, code formatting, refactoring, variable explorer, test explorer, and more!NOTE: Web support -- e.g., github.dev -- is limited.Installed extensionsThe Python extension will automatically install the Pylance and Jupyter extensions to give you the best experience when working with Python files and Jupyter notebooks. However, Pylance is an optional dependency, which means that the Python extension will remain fully functional if it is not installed. You can also uninstall it at the expense of some features if you are using a different language server.2- Python IndentLink: https://github.com/kbrose/vsc-python-indentIt is used to correct Python indentation in Visual Studio Code. How it worksEvery time you press the Enter key in a Python context, this extension will parse your Python file down to the location of your cursor, and determine exactly how much to indent the next line (or two in the case of hanging indents) and how much to indent nearby lines.There are three main cases when determining the correct indent. Review the documentation here: https://github.com/kbrose/vsc-python-indent3- Python Doctring GeneratorLink: https://github.com/NilsJPWerner/autoDocstringVisual Studio Code extension to quickly generate docstrings for python functions.FeaturesQuickly generate a docstring fragment that can be tabbed.Choose from several types of docstring formats.Infer parameter types via pep484 type hints, default values and var names.Support for args, kwargs, decorators, errors and parameter types.Docstring FormatsGoogle (default)docBlockrNumpySphinxPEP0257 (coming soon)UsageThe cursor must be on the line directly below the definition to generate a complete auto-populated docstring.Press enter after opening the docstring with triple quotes ("""" or ''')Keyboard shortcut: ctrl+shift+2 or cmd+shift+2 for macCan be changed in Preferences -> Keyboard shortcuts -> extension.generateDocstringCommand: Generate DocstringRight-click menu: Generate DocstringAlso read: 4 Must-Know Python Pandas Functions for Time Series Analysis4- Python ExtendedLink: https://github.com/tushortz/vscode-Python-ExtendedPython Extended is a vscode snippet that makes it easy to write Python code by providing completion options along with all arguments.UsageRun vscode and in a python file, type the name of the method to complete and press tab or enter on selection.How to installOpen vscode. Press F1, search for "ext install" followed by the extension name, in this case "ext install Python Extended" without the ">". Or if you prefer ">ext install", press enter, search for "Python Extended".5- Python PreviewLink: https://github.com/dongli0x00/python-previewA Visual Studio Code extension with debug preview support for the Python language.RequirementsInstall a version of Python 3.6 or Python 2.7. Make sure that the location of your Python interpreter is included in your PATH environment variable.It is best to install the Python extension for Python Intellisense.6- AREPL for PythonLink: https://github.com/almenon/arepl-vscodeAREPL automatically evaluates Python code in real time as you type.UsageFirst, make sure you have python 3.7 or higher installed.Open a python file and click on the cat in the top right bar to open AREPL. You can click the cat again to close it.Or run AREPL via the search command: control-shift-por use the shortcuts: control-shift-a (current document) / control-shift-q (new document)FeaturesReal-time evaluation: no need to run - AREPL evaluates your code automatically. You can control this (or even disable it) in the settings.Variable display: The final state of your local variables is displayed in a collapsible JSON format.Error display: The moment you make a mistake an error is displayed with the stack trace.Settings: AREPL offers many settings to suit your user experience. Customize the look and feel, bounce time, python options and much more.Aldo read: 3 Python Tricks That Will Improve Your Code7- Python PathLink: https://github.com/mgesbert/vscode-python-pathThis extension adds a set of tools to help generate internal import statements in a Python project.Features"Copy Python Path" is accessible from:Command lineExplorer context menuEditor context menuEditor title context menu8- Python Test ExplorerLink: https://github.com/kondratyev-nv/vscode-python-test-adapterThis extension allows you to run your Python Unittest, Pytest or Testplan tests with the Test Explorer user interface.How to get startedInstall the extensionConfigure Visual Studio Code to discover your tests (see the Configuration section and the documentation for the test framework of your choice:Unittest documentationPytest documentationTestplan documentationOpen the sidebar of the test viewExecute your tests via the Run icon in the Test ExplorerFeaturesDisplays a Test Explorer in the test view in the VS Code sidebar with all detected tests and suites and their statusConvenient error reporting during test detectionUnittest, Pytest and Testplan debuggingDisplays the log of a failed test when the test is selected in the explorerTest rerun when saving testsSupports multi-root workspacesSupports Unittest, Pytest and Testplan test frameworks and their plugins9- Python SnippetsLink: https://github.com/ylcnfrht/vscode-python-snippet-packA snippet package to make working with Python more productive This snippet package contains all of the following Python methodsall built-in python snippets and contains at least one example for each methodall python string snippets contain at least one example for each methodall python list snippets contain at least one example for each methodall Python set snippets contain at least one example for each methodall Python tuple snippets contain at least one example for each methodall python dictionary snippets contain at least one example for each methodAnd it contains many other code snippets (such as if/else, for, while, while/else, try/catch, file process, andclass snippets and class examples for oop (polymorphism, encapsulation, inheritance, etc.).If you don't use a method don't worry this extension contains a lot of code examples for each python method.This extension is not just a code snippet, it will also be useful for learning the python programming language.You will learn all python methods with a lot of code examples.For example, if you want to use the string replacement method, you just need to use .replace.But if you don't know how to use the replace method then use string.replace =>10- JupyterLink: https://github.com/Microsoft/vscode-jupyterA Visual Studio Code extension that provides basic notebook support for language kernels that are compatible with Jupyter Notebooks today. Many language kernels will work without any modifications. To enable advanced features, modifications to the VS Code language extensions may be necessary.Notebook supportThe Jupyter Extension uses VS code's built-in notebook support. This interface offers a number of advantages to notebook users:Out-of-the-box support for VS Code's wide range of basic code editing functions, such as hot output, search and replace, and code folding.Editor extensions such as VIM, bracket coloring, linters and many more are available while editing a cell.Deep integration with the general workbench and file-based features of VS Code, such as outline view (table of contents), breadcrumbs, and other operations.Fast load times for Jupyter notebook (.ipynb) files. Any notebook file is loaded and rendered as quickly as possible, while execution-related operations are initialized behind the scenes.Includes a notebook diff tool, which makes it easy to compare and visualize differences between code cells, results and metadata.Extensibility beyond what the Jupyter extension provides. Extensions can now add their own specific language or runtime to notebooks, such as the .NET and Gather interactive notebooks.Although the Jupyter extension comes with a comprehensive set of the most commonly used renderers for output, the marketplace supports installable custom renderers to make working with your notebooks even more productive. To get started writing your own, check out the VS Code renderer api documentation.You can also read data science posts in Spanish here.ConclusionThere are many extensions that you can use with your Visual Studio Code, and deciding which one to use will involve testing, reviewing utilities, use cases and so on in order to make your work easier while coding!Also read: Why Decorators In Python Are Pure Genius?

Join our private community in Discord

Keep up to date by participating in our global community of data scientists and AI enthusiasts. We discuss the latest developments in data science competitions, new techniques for solving complex challenges, AI and machine learning models, and much more!

Join our Discord