Front-End Development Building an Image Upload Feature with JavaScript Mastering Image Alignment: Centering Images with HTML & CSS Adding Video to Your React Native App with react-native-video HTML Image Slider: Do It Yourself and 1-Step Image Gallery Widget How to Effectively Manage Digital Assets in a PHP Image Gallery Introducing Angular Image Editor: Your New Editing Too Mastering Javascript Image Annotation Mastering JavaScript Image Popup Python Video Player: 3 Free Options and a Quick Tutorial Image Recognition Machine Learning: Use Cases and Common Algorithms HTML/CSS: How to Center Images Vertically and Horizontally How to Create an Image Map Understand CSS Background Position with 4 Simple Examples Java for Image Processing: 4 Libraries You Should Know Python Video Processing: 6 Useful Libraries and a Quick Tutorial Blur Image CSS: Two Ways to Blur Images for Gorgeous Effects Designing a Video Flipping App for Android Build an App for Embedding Video Watermarks on Android Devices Change Image on Hover with HTML and CSS How to Align Images with CSS Full Page Background Image with CSS: Tutorial and 5 Automation Tips Using CSS to Scale Page Elements and a Better Way to Scale Your Images CSS Background Image: Quick Tutorial and 3 Automation Tips Featured Image: Best Practices to Feature Images on Your Website Image Gallery Websites: Tips and Tricks for a Stunning Image Gallery 6 Ways to Stretch a Background Image with CSS Auto Cropping for Images and Video: Features & Best Practices FLAC vs. WAV: 4 Key Differences and How to Choose Converting Audio to Video: A Practical Guide FLAC vs. AIFF: 5 Key Differences and How to Choose FLAC vs. MQA: 5 Key Differences and How to Choose Converting WAV Files To OGG The Ultimate Guide On Converting OGG Files To WAV Sound Choices: FLAC vs. MP3 AAC vs MP3 – The Future of Audio Files All about AIFF and how it compares to WAV and MP3 Integrating Cloudinary with Netlify Integrating Cloudinary with Svelte and SvelteKit Integrating Cloudinary with Nuxt Integrating Cloudinary with Gatsby File Upload as a Service: How It Works and 5 Leading Solutions Native Mobile App Development Creative Uses for CSS Inner Border and 3 Ways to Set a Border Integrating Cloudinary with Next.js Front-End Development: The Complete Guide

Python Video Player: 3 Free Options and a Quick Tutorial

python video player

Python is a high-level, interpreted programming language known for its ease of learning and flexibility. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming.

Python comes with an extensive standard library that offers a range of functionalities, eliminating the need for external libraries for basic programming tasks. In addition, the Python ecosystem offers a wide range of libraries.

In this article, we’ll review three open source Python libraries that make it possible to play video within Python web applications, and show a tutorial for implementing a video player with one of them.

This is part of a series of articles about video optimization

In this article:

python video player

3 Modules and Libraries to Build a Video Player in Python


Python-vlc is a module that allows developers to leverage the VLC media player’s capabilities within Python applications. It acts as a binding to the VLC library, enabling control over media playback, including video files and streams. This module is useful for building a video player in Python as it handles the decoding and rendering of video content.

With python-vlc, developers can implement advanced video playback features, such as adjusting volume, seeking specific positions, and changing playback speed. The extensive features of the VLC media player make it an appropriate choice for developing sophisticated video playback applications in Python.


TkVideoPlayer is a Python library designed to integrate video playback capabilities into Tkinter applications. It extends the functionality of Tkinter and python-vlc, providing a higher level of abstraction for embedding videos in GUIs. It simplifies the process of creating a video player, allowing developers to focus on the application logic instead of the intricacies of video playback.

Utilizing TkVideoplayer in a project involves minimal setup, with straightforward methods to control the video, such as play, pause, and stop. Its compatibility with Tkinter makes it suitable for applications developed with Python’s standard GUI toolkit, ensuring a consistent user experience.


The cv2 library, part of OpenCV (Open Source Computer Vision Library), is a versatile library primarily known for its extensive capabilities in image and video processing. While it’s widely recognized for its applications in computer vision and machine learning, cv2 also offers functionalities for video playback. This makes it a useful tool for developers looking to incorporate video content into their Python applications, especially in contexts where video analysis or processing is required.

Using cv2 for video playback involves leveraging its high-level GUI features along with its video capture capabilities. Developers can load, display, and manipulate video frames in real-time, making cv2 an excellent choice for applications that require more than just basic playback functionality. For instance, it allows for frame-by-frame analysis, real-time video processing, and applying filters or transformations to video streams.

python video player

Adding a Video Player in Python with the python-vlc Module

Installing python-vlc

To install the python-vlc module, you’ll need to use pip, Python’s package installer. Follow the syntax below to install it:

pip install python-vlc

It’s important to note that the VLC media player must be already installed on your system to use the python-vlc module effectively. After the installation process is complete, you can verify the successful installation by importing the vlc module into a Python script with the following syntax:

import vlc

Save and run your Python file. If no errors occur, the python-vlc module has been installed correctly. If you encounter any issues, consult the following section.

Fixing Errors During python-vlc Installation

If you face errors while importing the python-vlc module, it might be due to the system not recognizing the libvlc.dll file. This can happen if the file path is not included in the system’s PATH variable. To resolve this, add the path to the libvlc.dll file, which is located in the VLC installation directory, to your system’s PATH variable.

In case you’re using a 32-bit version of the VLC media player with a 64-bit version of Python, you will face compatibility issues. Ensure that you install the 64-bit version of the VLC media player if you’re using the 64-bit version of Python.

To address the issue of the system not recognizing the libvlc.dll file, you can import the os module before importing the vlc module and add the VLC directory to the DLL search path as shown below.

On Windows use this command: os.add_dll_directory(r'C:\Program Files\VideoLAN\VLC')

On Ubuntu, ensure vlc is installed via apt installer instead of snap.

Embedding python-vlc into a Python Application

To embed python-vlc into your Python application, you can start with a simple video playback example. First, import the vlc module, and then create a MediaPlayer object with the video file you want to play:

import vlc

my_media = vlc.MediaPlayer("video.mp4")
While True:

python video player

In this example, a MediaPlayer object is created for the video file “video.mp4”, and the play() method is used to start playback.

You can download the sample video here.

Advanced python-vlc Implementation

For a more advanced usage scenario, such as getting the duration of a video file, you can use the following approach:

import time, vlc

def vlc_video(src):
    vlc_obj = vlc.Instance()
    vlcplayer = vlc_obj.media_player_new()
    vlcmedia = vlc_obj.media_new(src)


Let’s review the code step by step.

Importing required modules

  • time: This module is imported to use the sleep function, which pauses the execution of the program for a specified amount of time. This is necessary to allow the video player some time to load the video file and retrieve its properties, such as duration.
  • vlc: This module is the python-vlc package that enables Python scripts to control VLC media player functionalities.

Defining the video playback function

def vlc_video(src):

This function is defined to encapsulate the process of playing a video and obtaining its duration. It takes a single argument, src, which is the path to the video file that you want to play.

Creating VLC objects

vlc_obj = vlc.Instance()

A vlc.Instance object is created, representing an instance of the VLC media player. This object serves as the entry point to using the VLC functionalities through python-vlc.

vlcplayer = vlc_obj.media_player_new()

The media_player_new() method creates a new MediaPlayer object associated with the VLC instance. This object is used to control playback.

vlcmedia = vlc_obj.media_new(src)

The media_new(src) method creates a new Media object for the specified video source src. This media object holds the media resource to be played.

Configuring the media player


The set_media() method of the MediaPlayer object is used to assign the media object created earlier to the player. This effectively loads the video file into the media player for playback.

Starting playback

The play() method is called on the MediaPlayer object to start playing the loaded video file.

Pausing execution to load the video


The sleep() function pauses the execution of the script for 0.5 seconds. This delay gives the media player sufficient time to begin playback.

Using the function in your application

To use this function, you would call vlc_video("video.mp4"), replacing “video.mp4” with the path to the video file you want to play.

Managing and Optimizing Videos with Cloudinary

Cloudinary offers a powerful solution to optimize and serve video files efficiently, ensuring smooth playback across various devices and platforms. By leveraging Cloudinary’s comprehensive video management capabilities, you can significantly enhance video performance and streamline your workflow.

Cloudinary’s video optimization starts with the ability to automatically adjust the video format, resolution, and bitrate. This ensures that videos are delivered in the highest quality possible while minimizing load times and bandwidth usage. Here’s how you can use Cloudinary to optimize and serve videos for any Python video player:

First, you need to upload your video to Cloudinary. This can be done using Cloudinary’s Python SDK:

import cloudinary
import cloudinary.uploader


response = cloudinary.uploader.upload_large("path/to/your/video.mp4", resource_type = "video")
video_url = response['url']

Once your video is uploaded, Cloudinary provides dynamic URLs that can be used to apply various transformations on-the-fly. For example, to optimize the video for web playback, you can use the following URL transformation:

optimized_url = cloudinary.CloudinaryVideo("your_video_public_id").build_url(
        {'width': 'auto', 'dpr': 'auto', 'crop': 'limit'},
        {'quality': 'auto'}

This URL ensures that the video is dynamically adjusted for optimal performance and quality based on the viewer’s device and network conditions.

Integrating this optimized video into a Python video player is straightforward. Here’s an example using the vlc library:

import vlc

# Create a VLC instance
instance = vlc.Instance()

# Create a player object
player = instance.media_player_new()

# Set the media to the optimized URL
media = instance.media_new(optimized_url)

# Play the video

# Keep the video player running
while True:

By using Cloudinary’s dynamic URL transformations, you can ensure that your videos are always optimized for performance and quality, regardless of the playback environment. This not only enhances the user experience but also reduces the complexity and time required to manage video content.

Cloudinary’s powerful tools for video management and optimization provide a robust solution for developers looking to integrate high-performance video playback into their Python applications. By following these steps, you can efficiently manage and deliver video content, ensuring optimal performance across all devices and platforms.

Last updated: Jun 12, 2024