In almost all cases, this is a bad idea. Changing the system Python can and quite often will break some other packages depending on the previous environment or version. Upgrading from Python 3.10 to 3.13 means quite a few things have been changed and/or removed, making such problems likely.

So, how can you use a more modern version of Python?

One way ist the way you have already gone, installing it and accessing it via python3.13.

Another way is using the deadsnakes PPA, see e.g. this answer by Hannu (but refrain from overriding your system default).

And then there are multiple ways to get access to a specific Python version within a specific project, here is a small selection:

1. Pyenv is the classic solution for this. It allows you to download and install basically any Python version (even alpha and beta) and activate them dynamically or use them as the base for a virtual environment.
2. UV, a upcoming Python dependency manager, can manage Python versions as well. You just have to specify the desired Python version in a .python_version file in your project root directory.
3. Conda, another dependency manager, but not limited to Python, can also manage multiple Python versions.

//install python 3.6

sudo add-apt-repository ppa:jonathonf/python-3.6
sudo apt update
sudo apt install python3.6

//change default python

sudo rm /usr/bin/python
sudo ln -s /usr/bin/python3 /usr/bin/python

//view default

 python -V

Outdated:

Python 3.7.1 is still in maintenance version. It is only available for download to Windows and macOS users. Once the stable version is released, then it is made available in Linux repositories. For Windows and Mac users visit this python.org URL.

Currently (2022):

For Linux users: you can download the 3.11.0 version from the terminal

sudo apt-get update && sudo apt-get upgrade
sudo apt-get install python3.11

Check the most recent Python version available here: https://www.python.org/downloads/

As others already noted, bare sudo apt-get install package will install latest available version, replacing the older one if needed.

But with some software (among which is Python) the situation is somewhat different. Some major, very- and incompatibly-different versions get their own packages. For instance, Python 2.6, Python 2.7, Python 3.1 all live in separate packages on Ubuntu.

Of particular importance is the fact that one of Ubuntu policies is to extensively use Python for writing end-user software. So in fact, fairly large part of the system is written in Python. At the moment, the code runs on Python 2.6 — so this version is the default upon installation; and the code won't easily run on, say, Python 2.7 — because incompatibilities exist. To switch the system to Python 2.7 there needs to be done a piece of work, consisting of updating and re-testing all the scripts. This can't be done easily; that is, you can't just "switch" your system to Python 2.7 and delete the older version.

But. If you don't care about fancy gears of your system and just need newer Python — see no obstacles. Go and sudo apt-get install python3 and code for 3.x Python bravely; just remember to launch your scripts with python3 and use #!/usr/bin/env python3 shebang line.

Upd: I keep seeing this upvoted; notice that this is a fairly old answer, things have changed.

What to learn next

From a superuser perspective (not Python developer's), the next things I'd suggest learning to use:

• pip/pip3/python3 -m pip — this is the npm for Python. Quick tip: try pip3 install --user howdoi (may need to apt install python3-setuptools python3-pip once, before that works). Then for example, howdoi --all compile python3 ubuntu.

• The virtualenv tool. It's 100% developer-oriented, but you'll likely need to use it (perhaps underneath a few wrappers, such as tox or pipx) to work with people's source packages.
  Ruby's bundler or Cabal sandbox may be familiar analogues.

• The conda tool — which is a totally separate python package repository and installer (think: fork of PyPi).

There's humongous variety of tools in the Python ecosystem in 2020. At the very least, make yourself comfortable with pip before going deeper.

Basic pitfalls

For the brave but unwary, a few classic pitfalls when trying to manually set up a newer CPython on Ubuntu.

• Leave /usr alone; you can look but you don't touch. Leave it to dpkg, save yourself some confusion. You have the whole /usr/local at your disposal:

  sudo chown -R `whoami` /usr/local
  pip3 install --prefix=/usr/local pydf
  

• Compiling CPython from source is well-explained on the web; just don't forget your /usr/local prefix. This is the best way to manually test patches and/or pre-releases (those alpha-, rc- builds) of CPython itself. To wipe built artifacts, you can just rm -rf /usr/local/*; sudo ldconfig.

• Finding a PPA is decent option too; keep in mind that a PPA is just someone else's private build. Look for credible PPAs with CI/CD running.

A terminal in a unix-based OS (including Darwin / MacOS and Linux) will search for the command you have typed in several places, in order, and the first match found will stop the search from finding other possible commands with the same name.

To simplify the answer, I'll limit this to the bash shell as I don't use ZSH, but I think the answer should be similar in both shells.

After you type in a line of input and hit enter, your shell will modify its input so that it expands variable interpolations and such things and then will take the first token (first "word") and search for that word as a command name.

Commands can be found in several places, from builtin commands, to aliases, to shell functions and if the command can't be found there, the shell will begin looking at specific locations in your filesystem to look for files that are named the same as your command. The first match wins, so if you have several pythons in your PATH, the first one will be the one that is selected.

The set of locations in your filesystem the shell will look for the command is stored in an environment variable called PATH in the shell and is generally available to view and set.

to see what your path is:

echo ${PATH}

or. for slightly easier reading:

echo ${PATH} | sed 's/:/\n/g'

which python will let you see what python version your shell is finding first in the PATH and type python will let you know if for some reason you have a function or alias named python that happens to overshadow your filesystem python executables.

Also, bash maintains an internal hash table of where it has previously found commands. So if you type python and bash finds it in /usr/bin/python, then it will remember that for the rest of the session. If you'd like it to look again, because perhaps you have installed a new python you expect it to find first, you can type hash -r to reset the hash table to a blank new one.

All that being said, if you are starting to develop in Python, you're going to need to handle different versions of Python.

To start down that road, check out:

• asdf
• pyenv

I recommend asdf as it can work for many things, not just python. Also, you'll probably want a decent dependency manager sooner rather than later for your project, so I'd check out poetry and pipenv:

• Poetry
• Pipenv

The best way I've found is to run this command from terminal

sudo pip install [package_name] --upgrade

sudo will ask to enter your root password to confirm the action.

Note: Some users may have pip3 installed instead. In that case, use

sudo pip3 install [package_name] --upgrade