Question: CPython has a Global Interpreter Lock (GIL). 

So, multiple threads cannot concurrently run Python bytecodes.

What then is the use and relevance of the `threading` package in CPython ?

Answer: 
During I/O the GIL is released to other threads can run.
Also some extensions (like `numpy`) can release the GIL when doing calculations.

So an important purpose is to improve performance on not CPU-bound programs. From the Python documentation for the `threading` module:

> 
> CPython implementation detail: In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use `multiprocessing` or `concurrent.futures.ProcessPoolExecutor`. However, `threading` is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.
> 
> 
> 

Another benefit of threading is to do long-running calculations in a GUI program without having to chop up your calculations in small enough pieces to make them fit in timeout functions.

Also keep in mind that while CPython has a GIL *now*, that might not always be the case in the future.
When python runs some code, the code is compiled in "atomic" commands (= small instructions). Every few hundred atomic instructions python will switch to the next thread and execute the the instructions for that thread. This allows running code pseudo-parallel.
Lets assume you have this code:

```
def f1():
    while True:
        # wait for incomming connections and serve a website to them
def f2():
    while True:
        # get new tweets and process them

```

And you want to execute `f1()` and `f2()` at the same time. In this case, you can simpy use `threading` and dont need to worry about breaking the loops every now and then to execute the other function. This is also way easier than asynchronous programming.

Simple said: It makes writing scripts which needs to do multiple things easier.

Also, like @roland-smith said, Python releases the GIL during I/O and some other low-level c-code.