A Jupyter Notebook can be converted to markdown, using the command:

$ jupyter nbconvert nombre_del_notebook.ipynb --to=markdown

The result is a file extension .mdquite similar to what was indicated in the question. In that file the text cells have been converted to markdown (compatible with the one used by Stack Overflow), the code cells have been dumped as is but delimited by the triple tick (```) that makes them look correctly in Stack Overflow, and the cell outputs (the output) are displayed as is but indented four spaces, which will cause Stack Overflow to display them as code as well.

The problem is that this command must be executed from the command line, which requires Jupyter to be installed (and the notebook to be exported previously downloaded from Colab).

The problem with Colab

Colab has a somewhat peculiar architecture. A Jupyter notebook is on the one hand a file (typically with the extension .ipynb), but on the other hand it is more than just a file, since it is "alive" (code can be added to it, it can be executed and the result can be seen). To enable the latter, a machine running a Python interpreter (what Jupyter calls the execution kernel ) is needed, which receives the contents of the cell to be executed and returns the result.

Google Colab separates, on the one hand, the storage of the .ipynb file (which is saved in the user's Google Drive unit) and, on the other hand, the execution of the .ipynb (which occurs in a virtual machine that Google starts and that contains python preinstalled, a Jupyter runtime kernel, and lots of typical scientific packages). That virtual machine is "ephemeral" (if you don't use it for a while it will be destroyed), but while it exists you can install things on it and it has its own file system. And when you reopen the notebook, if the machine had been shut down, a new one will be created again.

From a Jupyter notebook "system" commands preceded by a can be executed !, in the case of Colab and these commands are executed in the virtual machine described above.

So we could think that the command jupytershown above could also be executed from the notebook itself, putting in a cell:

!jupyter nbconvert nombre_del_notebook.ipynb --to=markdown

But the problem is that the file .ipynbis not on the disk of the virtual machine (or at least it is not in any folder accessible from the notebook itself), but it is stored in Google Drive, which complicates things.

The solution

It is necessary to insert a cell that, through Python code, allows the connection between the notebook and the Google Drive, to transfer a copy of the .ipynb of the Drive to the virtual machine from which the command can already be executed !jupyter nbconvert.

The following code (whose operation I will explain next) would do everything necessary:

# IGNORE
# @title Generate Stack Overflow text
notebook_name = "Pruebas.ipynb"

from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials

# Conexión con Drive
auth.authenticate_user()
gauth = GoogleAuth()
gauth.credentials = GoogleCredentials.get_application_default()
drive = GoogleDrive(gauth)

# Descarga del notebook
file_id = drive.ListFile({'q': f"title='{notebook_name}' and trashed=false"}).GetList()[0].attr["metadata"]["id"]
downloaded = drive.CreateFile({'id': file_id})
with open(notebook_name, "w") as f:
  f.write(downloaded.GetContentString())

# Conversión a markdown
txt = !jupyter nbconvert {notebook_name} --to=markdown --RegexRemovePreprocessor.patterns="['^# IGNORE', '^\s+$']" --stdout
txt = "\n".join(txt[1:])
print(txt)

• The first line with # IGNORE, although it is a comment, is there to prevent this cell from also being part of the resulting markdown, as we will see later.

• The line with # @titleis to make this cell "collapsible" in Colab, so we don't see its code (by double-clicking on the cell title), which makes the workbook cleaner.

• The mapping notebook_name = "Pruebas.ipynb"should be changed to the name of the Colab notebook you want to convert (it can be the same as the one in this cell, or something else).

• The part that says "Connecting to Drive" will cause a URL to appear for the user to connect to, which will take them to OAuth2 authorization which will grant this notebook permissions to access Drive. From that page you will get a code that you must then paste into an input to continue. Once that is done, and as long as this notebook is not shut down, you will not be prompted for this authorization again. This cell can be executed several times if modifications are made to the notebook and the new markdown version is to be obtained. Only the first time authentication is required.

• The part that says "Download the notebook" deals with searching Drive for the document with the name that we have assigned in notebook_name, and downloading it to the virtual machine in which the kernel of this notebook is running.

• Finally, the command is executed jupyter nbconverton that virtual machine, with the appropriate options to generate the desired markdown, and to skip the cells that start with # IGNORE. The result of that conversion is sent to standard output ( option --stdout) from which it is captured by the notebook to store in the variable txt.

• This variable is a list of strings, each string being each of the lines that the command has produced. The first of those lines is a message from nbconvert, which isn't really part of the output, so we skip it, and the rest we concatenate with newlines. Finally we printtxt

The result of all of the above is that the markdown version of the notebook is displayed as the output of this cell. That text is ready to be copied (Ctrl+A to select, Ctrl+C to copy) and pasted into SOes (Ctrl+V).

warnings

Some things don't work directly:

• Colab supports math text in markdown, using LaTeX syntax. When copying and pasting into SOes the LaTeX syntax is kept, but not the "rendered" version (SOes doesn't have a renderer for LaTeX to display correctly)
• Some Colab cells can produce graphics. When converting to markdown these are replaced by type bindings ![asi](fichero.png)that won't work correctly on OSes. Graphics must be copied and pasted separately into SOes.
• Some Colab cells produce tables (for example pandas). Converting them to markdown renders them as HTML, which is not supported by OSes. Be careful to use in those cells print(df)(instead of just df) so that the output is ASCII instead of an HTML table.
• If the cell that does the conversion to Markdown is part of the notebook that you want to convert, you must be careful to delete the output of previous executions of said cell, and to save (Ctrl+S) the notebook before executing it again ( so that the copy in Drive is updated at that time).

show

The following image shows an example notebook as seen in Colab:

The last cell of that notebook contains the code explained above. Executing that cell produces the following output, which is the contents of the notebook in markdown, ready for copy and paste:

## Ejemplo

Esta celda contiene **markdown**, y es _una prueba de concepto_.

Ahora una lista sin numerar

* Primer elemento
* Segundo

Fin de la celda markdown.


```python
# Esta ya es una celda de código
for i in range(10):
  print(2**i)
```

    1
    2
    4
    8
    16
    32
    64
    128
    256
    512


Un ejemplo que muestra una gráfica


```python
import pandas as pd
import random

_ = pd.DataFrame({"Ejemplo": [random.random() for _ in range(100)]}).plot()
```


![png](Pruebas_files/Pruebas_3_0.png)


Un ejemplo que muestra una tabla (usando `print()` para evitar la salida HTML)


```python
df = pd.DataFrame({"Fruta": ["Manzana", "Naranja", "Piña"], 
              "Precio": [12, 15, 30]})
print(df)
```

         Fruta  Precio
    0  Manzana      12
    1  Naranja      15
    2     Piña      30

If I copy and paste that text into SOes, I'll have to manually edit the line that contained the image, which read:

![png](Pruebas_files/Pruebas_3_0.png)

and put in its place the image that I can copy and paste directly from the cell that produced it.

The result would be the following:

Example

This cell contains markdown , and is a proof of concept .

Now an unnumbered list

• first element
• Second

End of cell markdown.

# Esta ya es una celda de código
for i in range(10):
  print(2**i)

1
2
4
8
16
32
64
128
256
512

An example showing a graph

import pandas as pd
import random

_ = pd.DataFrame({"Ejemplo": [random.random() for _ in range(100)]}).plot()

An example showing a table (using print()to avoid HTML output)

df = pd.DataFrame({"Fruta": ["Manzana", "Naranja", "Piña"], 
              "Precio": [12, 15, 30]})
print(df)

     Fruta  Precio
0  Manzana      12
1  Naranja      15
2     Piña      30