How to use Brython in the Browser

Brython is a Python implementation that can be used in the browser to write and run Python code. Here are the steps to use Brython in the browser:

  1. Download Brython: Visit the Brython website ( and download the latest version of Brython. You can either download the full package or just the minified version.
  2. Create an HTML file: Create an HTML file in your preferred text editor and save it with a .html extension. This will be the file that you will use to run your Brython code.
  3. Add the Brython script tag: Add the Brython script tag to the head section of your HTML file. This will load the Brython library and make it available for use in your code. The script tag should look like this:
<script type="text/javascript" src="path/to/brython.js"></script>

Replace “path/to/brython.js” with the actual path to the Brython library on your computer.

4. Add a script tag for your Python code: Add a script tag to the body section of your HTML file. This is where you will write your Python code. The script tag should look like this:

<script type="text/python">
   # Your Python code goes here

5. Run your code: Open your HTML file in a web browser and your Brython code will run.

That’s it! You can now use Brython in the browser to write and run Python code. Keep in mind that Brython does not support all Python modules, so you may need to use alternative libraries for certain tasks.

The DOM Application Program Interface in Brython:

The DOM (Document Object Model) API in Brython allows you to interact with the HTML elements of a web page and manipulate them dynamically using Python code. Here are some key aspects of the DOM API in Brython:

  1. Importing the DOM API: To use the DOM API in Brython, you need to import the browser module. You can do this by adding the following line of code at the beginning of your Python script:
from browser import document, window

The document object represents the entire HTML document, while the window object represents the browser window.

2. Accessing HTML elements: You can access HTML elements using the document object. For example, to access an element with a specific id attribute, you can use the getElementById method:

element = document.getElementById("myElement")

This will return a reference to the HTML element with id “myElement”.

3. Manipulating HTML elements: Once you have a reference to an HTML element, you can manipulate its properties and attributes using Python code. For example, you can change the text content of an element using the textContent property:

element.textContent = "New text content"

You can also add, remove, or modify attributes of an element using the setAttribute, removeAttribute, and getAttribute methods.

4. Event handling: Brython allows you to handle events (such as clicks or key presses) on HTML elements using Python code. You can use the addEventListener method to register an event handler function for a specific event:

def click_handler(event):
    print("Button clicked!")

button = document.getElementById("myButton")
button.addEventListener("click", click_handler)

This code will add a click event handler to the HTML element with id “myButton”, which will call the click_handler function when the button is clicked.

These are just some of the basic features of the DOM API in Brython. There are many more methods and properties available that allow you to create dynamic web pages using Python code.

Importing file in the Brython:

In Brython, you can import Python modules and files using the import statement, just like in regular Python. Here are the steps to import a file in Brython:

  1. Create a Python file: Create a Python file with the code you want to import. For example, you can create a file called with the following code:
def say_hello(name):
    print("Hello, " + name + "!")

2. Save the file: Save the file in the same directory as your HTML file that will run the Brython code.

3. Import the file: In your main Python script, use the import statement to import the file. For example, you can import like this:

from my_module import say_hello

  1. This will import the say_hello function from and call it with the argument “John”.

Note that when you import a file in Brython, it is executed just like any other Python script, so any code in the file will be run. Therefore, it’s best to keep your imported files as simple modules containing only functions or classes that you want to use in your main script.

Also, keep in mind that not all Python modules will work in Brython, especially if they depend on system-level functionality that is not available in the browser. You may need to use alternative libraries or implement your own functionality in some cases.

Reduce the Import Size:

When using Brython, you may encounter situations where the size of the imported modules is too large and may affect the loading time of your web page. To reduce the import size, you can use the __pragma__ statement in your Python code.

The __pragma__ statement is a special directive that can be used to include or exclude specific lines of code from the compilation process. Here are some ways you can use __pragma__ to reduce the import size:

  1. Use __pragma__("skip") to exclude large modules: If you have a large module that you don’t need in your Brython code, you can exclude it using __pragma__("skip"). For example, if you don’t need the time module, you can skip it like this:
import time

This will exclude the import time statement from the compiled code, reducing the size of the imported modules.

2. Use __pragma__("js", ...) to use JavaScript code: If you need to use functionality that is only available in JavaScript, you can use pragma(“js”, …)to include JavaScript code directly in your Python code. For example, if you need to use thesetTimeout` function in JavaScript, you can do this:

__pragma__("js", """
function myTimeoutFunction() {
    // JavaScript code goes here
setTimeout(myTimeoutFunction, 1000);
  1. This will include the JavaScript code in the compiled code, allowing you to use JavaScript functionality directly in your Brython code.

By using __pragma__ statements strategically in your Python code, you can reduce the size of the imported modules and improve the loading time of your web page. However, keep in mind that this technique may not always be appropriate or necessary, and you should only use it when you have a specific need to reduce the import size.


In conclusion, Brython is a powerful tool that allows you to write Python code that runs in the browser. With Brython, you can create dynamic web pages that leverage the power of Python, without requiring your users to install any additional software.

Using the DOM API in Brython, you can manipulate HTML elements and create dynamic user interfaces directly from your Python code. By importing Python modules and files, you can extend the functionality of Brython and create complex web applications.

To optimize the performance of your Brython code, you can use the __pragma__ statement to reduce the size of imported modules and include JavaScript code directly in your Python code.

Overall, Brython is a versatile and powerful tool for building web applications with Python, and it offers many advantages over traditional web development technologies. If you’re a Python developer looking to build web applications, Brython is definitely worth exploring.