DEV Community: threadspeed

Plots with Plotly

threadspeed — Mon, 08 Jun 2020 22:43:47 +0000

Python programmers often use matplotlib to create plots, you can make all kinds of charts with it like bar charts or line charts. But this is not the only way to visualize your data.

A popular alternative the plotly module. This service lets you create plots and put them online. You should learn Python before trying plotly.

Create a bar plot

Creating a bar plot is done with a few lines of code.
To get started install plotly and chart-studio

pip install plotly==4.8.1 --user           
pip install chart-studio==1.0.0 --user

A simple bar plot can be created like this:

import plotly.graph_objects as go
fig = go.Figure(data=go.Bar(y=[2, 3, 1]))
fig.show()

So the data in this case is a list with integers, but the list can contains different data types.

That opens up a server on localhost showing the bar plot. You can also save them to a file or host them online.

To share them online, import chart_studio and set your api keys.

import chart_studio
chart_studio.tools.set_credentials_file(username='DemoAccount', api_key='lr1c37zw81')

That gives you this code:

import plotly.graph_objects as go
import chart_studio
import chart_studio.plotly as py

chart_studio.tools.set_credentials_file(username='DemoAccount', api_key='lr1c37zw81')

data = [go.Bar(y=[1,2,3,4,5,6])]
py.plot(data, filename='bar-plot')

After setting up, you will get a bar chart like this.

Line chart

If you want a line chart, you can change it. It's very important to change the filename, or it will overwrite your previous chart.

g1 = go.Scatter(x=[1, 2, 3, 4], y=[2, 4, 6, 8])
g2 = go.Scatter(x=[1, 2, 3, 4], y=[5, 10, 15, 20])

data = [g1,g2]
py.plot(data, filename='line-plot')

That results in this line chart demo

Why is this 'raw_input' detected as an error in Python?

threadspeed — Fri, 05 Jun 2020 22:39:05 +0000

If you get this error, you may be using an old version of Python or using old documentation.

In Python 3, the raw_input() function is no longer available, it's now deprecated.

Python 3 is not backwards compatible with Python 2. You should be using Python 3 or newer. If you have old code, you'll have to port it. (what's different?)

PEP 3111: raw_input() was renamed to input(). That is, the new input() function reads a line from sys.stdin and returns it with the trailing newline stripped. It raises EOFError if the input is terminated prematurely. To get the old behavior of input()
, use eval(input()).

input()

Python 3 comes with the method input() to take keyboard input. It returns data in the form of a string, so you can do this

    x = input("Enter x")
    print(x)

But if you check the type, with type(x) it will output that the data type is str. If you do not want that, you can cast the data.

    x = int(x)

You can also cast it to a data type directly, if you don't want to do input validation

    x = int(input("Enter x:"))

But it's wise to do input validation, a user might do this:

    >>> x = int(input("Enter x:"))
    Enter x:hello
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: invalid literal for int() with base 10: 'hello'
    >>>

You could create a function for that

    >>> def inputi(s):
    ...     x = 0
    ...     try:
    ...         x = int(input(s))
    ...     except:
    ...         print("Wrong input, type integer.")
    ...         return -1
    ...     finally:
    ...         return x
    ... 
    >>> x = inputi("Enter x:")
    Enter x:5
    >>> x = inputi("Enter x:")
    Enter x:hello
    Wrong input, type integer.
    >>>

If you are new to Python, this is a good starting point Learn Python or the Python shell tutorial

Start with Programming, where to start?

threadspeed — Tue, 26 May 2020 22:48:50 +0000

So you decided to learn programming, but where to start?

With all the languages it can be overwhelming. If you are totally new, I recommend learning Python or Javascript.

This is a collection of resources to help you out. That can be a good starting point, depending on your mode of learning (some people prefer books)

Python

Python is a language that is "easy" for new programmers because of the many introductory resources and syntax.

That said, it will take some time to master if you never programmed before. The language can be used on the Raspberry Pi but also on the desktop computer.

You can also learn from a book/course, I recommend this one.

JavaScript

JavaScript is the language for the web. Every web app uses JavaScript and it's supported by all web browsers.

Both JavaScript and Python work on all computer systems. But JavaScript will run directly with any website you put it on, on every device (including television, watch, mobile phone etc).

How do I display an Image in PyQt5/PySide2?

threadspeed — Sun, 24 May 2020 13:35:13 +0000

The QPixmap class is used to display the image inside a PyQt/Pyside window, either as a QPainterDevice object or loaded into a control, usually a label or button.

QPixmap can read image file types such as BMP, GIF, JPG, etc. If you want to display animated GIFs, you can use QMovie. PyQt can also display videos.

QPixmap is one of the widgets used to process images. It is optimized for displaying images on the screen. In our code example, we will use QPixmap to display the image on the window.

If you are new to PyQt, I suggest this course/book.

PyQt show image

The code below loads an image using a QPixmap. It attaches the QPixmap to a QLabel. The label is added to an QHBoxLayout and the QHboxLayout to the window.



from PyQt5.Qt import (QWidget, QHBoxLayout, QLabel, QApplication)                                                                          
from PyQt5.QtGui import QPixmap                                                                                                            
import sys                                                                                                                                 

class Example(QWidget):                                                                                                                    
    def __init__(self):                                                                                                                    
        super().__init__()                                                                                                                 
        self.initUI()                                                                                                                      

    def initUI(self):                                                                                                                      
        hbox = QHBoxLayout(self)                                                                                                           
        pixmap = QPixmap("cat.jpg")                                                                                                        

        lbl = QLabel(self)                                                                                                                 
        lbl.setPixmap(pixmap)                                                                                                              

        hbox.addWidget(lbl)                                                                                                                
        self.setLayout(hbox)                                                                                                               

        self.move(300, 200)                                                                                                                
        self.setWindowTitle('Image with PyQt')                                                                                             
        self.show()                                                                                                                        

if __name__ == '__main__':                                                                                                                 

    app = QApplication(sys.argv)                                                                                                           
    ex = Example()                                                                                                                         
    sys.exit(app.exec_())

In our example, we display the image on the window.



pixmap = QPixmap("cat.png")

We create a QPixmap object. It takes the name of the file as an argument.



lbl = QLabel(self)
lbl.setPixmap(pixmap)

We put the pixmap into the QLabel widget.
Alternatively you can use designer.

PySide2 show image

The PySide2 version is similar. Both the PyQt and PySide toolkits are actively maintained, and by now more or less equal in features and quality. There are only few, rather unimportant differences.



import sys                                                                                                                                 
from PySide2.QtGui import QPixmap                                                                                                          
from PySide2.QtWidgets import QMainWindow, QApplication, QLabel                                                                            

class MainWindow(QMainWindow):                                                                                                             

    def __init__(self):                                                                                                                    
        super(MainWindow, self).__init__()                                                                                                 
        self.title = "Load image in PySide2"                                                                                               
        self.setWindowTitle(self.title)                                                                                                    

        label = QLabel(self)                                                                                                               
        pixmap = QPixmap('cat.jpg')                                                                                                        
        label.setPixmap(pixmap)                                                                                                            
        self.setCentralWidget(label)                                                                                                       
        self.resize(pixmap.width(), pixmap.height())                                                                                       

app = QApplication(sys.argv)                                                                                                               
w = MainWindow()                                                                                                                           
w.show()                                                                                                                                   
sys.exit(app.exec_())

Reference

How can I create a directly-executable cross-platform GUI app using Python?

threadspeed — Fri, 22 May 2020 12:37:14 +0000

The Python programming language works on many platforms including Microsoft Windows, Apple Mac OS X, many Linux distributions other systems.

This article consists of two parts:

GUI module - how to create a desktop interface with Python
Python to Executable - turn a Python program into an executable

The hardest part is learn Python, how to use a GUI module. To create an executable, there are several command line tools.

GUI module

The first thing you will need is a GUI module. Of course, there are many GUI modules for Python. The most commonly used GUI modules are:

Tkinter - this module is based on the old Tk GUI toolkit. It is the default GUI library for python and it is free for commercial projects. Tk is rather limited with the number of widgets and has an old design.

PyQt - Python bindings for the Qt framework. It's free (gpl) but not for commercial products. Qt comes with many widgets and features and is under continuous development. If you are new to PyQt, I recommend this course & book.

PyGTK, a wrapper on the GTK toolkit. The gnome (gtk) desktop environment is an option on Linux systems.

Python is interpreted

Strictly speaking, you don't have to compile python for Mac/Windows/Linux because it is an interpreted language.

That means that if you have the Python interpreter installed on the platform and the required modules, you can run the program.

Python is installed on every Linux, Mac and Windows OS (I think) by default now. So all you need is have the non-standard modules installed if you use them.

However, your end-users may not be familiar with Python and other installing modules, so you may want to create an executable and an installer.

It is possible to build executables with the python interpreter, which we will discuss in the next section.

Create executable

After you made your GUI program in Python, you can convert it into a standalone executable. There are several tools that can do this, there is more than one way to do this.

Cross platform, all platforms

PyInstaller - PyInstaller freezes Python apps into stand-alone executables for Windows, Linux, Mac OS X, FreeBSD, Solaris and AIX. It supports Python 2.7 and Python 3.3, 3.4, 3.5 and 3.6.

First install it with the pip package manager:

pip install pyinstaller

Then run pyinstaller in your programs folder:

pyinstaller file.py

fbs - package Python apps that use PyQt. See Python PyQt to executable. fbs is not free for commercial use, but for non-commercial use it's free. It comes with setup program for your end-users.

Windows executable

py2exe - converts your Python program to a windows executable. It's only for building executables on Windows, you can't build a Windows executable from Linux or Mac OS X.

Linux executable

Freeze - works like py2exe but for the Linux platform

python freeze.py hello.py

Mac executable

py2app - create Mac OS executables from Python. py2app is similar in purpose and design to py2exe for Windows.

PyQt QInputDialog

threadspeed — Fri, 22 May 2020 10:24:14 +0000

With PyQt you can create a QInputDialog (graphical input dialog). PyQT is a GUI module for Python. It's a binding for the popular Qt framework.

A dialog without input is called a messagebox (QMessageBox).

The input dialog typically consists of a text box and two buttons, the user clicks OK (or Enter), the Dialog collects the input data and returns.

The available dialogs are:

QInputDialog.getText One line of text
QInputDialog.getMultiLineText multi-line text
QInputDialog.getDouble floating point
QInputDialog.getInt Integer
QInputDialog.getItem entry selection

QInputDialog example

The example below creates various input dialogs. It includes the single line, multi line, double/float input, integer input and a select box.

It shows them one by one in series, not all at once. You have to click an option to show the next dialog.

import sys                                                                                                                                 
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QDialog, QInputDialog                                                      
from PyQt5.Qt import Qt                                                                                                                    

class App(QWidget):                                                                                                                        
    def __init__(self):                                                                                                                    
        super().__init__()                                                                                                                 
        # text input                                                                                                                                    
        text, ok = QInputDialog.getText(self, 'getText', 'Enter text')                                                                     
        if ok and text:                                                                                                                    
            print(text)                                                                                                                    

        # multi-line input                                                                                                                       
        text, ok = QInputDialog.getMultiLineText(self, 'getMultiLineText', 'Story', "Enter story")                                         
        if ok and text:                                                                                                                    
            print(text)                                                                                                                    

        # enter double                                                                                                                 
        double, ok = QInputDialog.getDouble(self, 'getDouble', 'Enter double', 22.33, -10000, 10000, 2)                                    
        if ok:                                                                                                                             
            print(double)                                                                                                                  

        # enter integer                                                                                                                                   
        int, ok = QInputDialog.getInt(self, 'getInteger', 'Enter number', 25, 0, 100, 1)                                                   
        if ok:                                                                                                                             
            print(int)                                                                                                                     

        # select option                                                                                                                                   
        items = ["Spring", "Summer", "Fall", "Winter"]                                                                                     
        item, ok = QInputDialog.getItem(self, 'getItem', 'Favourite season', items, 0, False)                                              

        if ok and item:                                                                                                                    
            print(item)                                                                                                                    

if __name__ == '__main__':                                                                                                                 
    app = QApplication(sys.argv)                                                                                                           
    ex = App()                                                                                                                             
    sys.exit(app.exec_())

Related links:

PyQt GUI with Python

threadspeed — Fri, 22 May 2020 09:44:32 +0000

PyQt is a cross-platform toolkit for creating GUI applications that integrates Python with the Qt library.

That is, PyQt allows the use of the Python language to call APl from the Qt library, greatly improving development efficiency while retaining Qt's high operational efficiency.

Because it's much faster to develop programs in Python than in C++, PyQt wraps Qt completely and can do almost anything Qt can do with PyQt.

import sys
from PyQt5.QtWidgets import QApplication,QWidget

if __name__ == '__main__':
    app = QApplication(sys.argv) # Create an instance of the QApplication class
    w = QWidget() #Create a window
    w.resize(400,200) #Setting the window size
    w.move(300,300) #move window
    w.setWindowTitle("The first PyQt5-based desktop application") #setWindowTitle
    w.show() #display window

    sys.exit(app.exec_()) #Enters the main loop of the program and ensures the main loop ends safely with the exit function

The function of app.exec_() is to run the main loop, which must be called to start the event processing, and the method is called to enter the main loop of the program until the exit() is called.

If you are new to PyQt, I recommend this book

QApplication

The QApplication class manages the control flow and major settings of GUI applications. It can be said that QApplication is the lifeblood of Qt's entire back-office management.

    app = QApplication(sys.argv) # Create an instance of the QApplication class

It contains the main event loop in which all events from the window system and other resources are processed and scheduled.

It also handles the initialization and termination of applications and provides conversation management. It also handles most system-wide and application-wide settings.

For any GUI application that uses Qt, there has to be a QApplication object

QWidget

The QWidget class is the base class for all user interface objects. This includes buttons, labels, text input, progressbar, messagebox and a lot more.

QDialog

The QDialog class is the base class of the dialog window. This lets you create dialogs.

QMainWindow

The QMainWindow class provides a main application window with menu bars, toolbars, status bars (e.g., IDE-Visual Studio, Qt Creator, etc.) that is commonly used for developing Qt.

A main window provides the user interface framework for building the application. qt has QMainWindow and its related classes to manage the main window

QWebEngineView

PyQt5 uses the QWebEngineView control to display HTML pages. Older versions of the QWebView class are not maintained because QWebEngineView uses the Chromium kernel to give users a better experience.

GUI Library for Python

threadspeed — Thu, 21 May 2020 23:25:44 +0000

In general, choosing a GUI toolkit for an application can be tricky.

Programmers who use Python (and many languages as well) have a wide variety of GUI toolkits to choose from, and each has its own advantages and disadvantages.

Some are faster than others, some are smaller, some are easy to install, and some are more suitable for cross-platform use (for this, also note that some support specific features you need to meet). Of course, the various libraries have various licenses accordingly.

Python GUI modules

tkinter

For Python programmers, the default GUI choice is Tk (bound via Tkinter) - for obvious reasons. tkinter and the idle IDE were written by Python's founders, and they came about as the default choice for most Python distributions.

The standard Python documentation discusses Tkinter, but does not address any other GUI bindings. It was intentional! To say the least, if Tk and Tkinter weren't so bad, programmers would have no reason to look for alternatives.

PyQt

PyQt has far more advantages than Tkinter (which also has several disadvantages);

PyQt is a Python binding for the Qt framework. Qt and PyQt are completely object-oriented in design; and Qt provides a well-designed collection of window building blocks that are much larger than what Tk provides.

Some of the PyQt widgets are shown below:

If you are new to PyQt, I recommend this book and course.

In terms of its drawbacks, Qt's license is more restricted than many toolkits (at least for non-Linux platforms); Qt is a fairly large library.

PyQt strictly follows Qt's licensing. In particular, it is available for GPL on the UNIX/X11 platform and for commercial purposes there's another license.

Qt uses a mechanism called signals/slots to pass events and messages between window artifacts (and other objects). This mechanism is completely different from the callback mechanism used in most toolkits, including Tkinter.

The larger the application, the more important this advantage of PyQt becomes.

GUI Demo App: log counter

To show the contrast between the signal/slot and the callback, we provide a write-and-play application that uses Tkinter and PyQt.

The application consists of four window components.

"Quit" button (to quit)
"Log Timestamp" button (for messages)
A text area that displays a scrollable list of time stamps for logged logs
Message window component that displays the number of time stamps for logged

Tkinter example

In Tkinter, we can implement the application like this.

Logger Tkinter application

import sys, time
from tkinter import *

class Logger(Frame):
    def __init__(self):
        Frame.__init__(self)
        self.pack(expand=YES, fill=BOTH)
        self.master.title("Timestamp logging app")
        self.tslist = []
        self.tsdisp = Text(height=6, width=25)
        self.count = StringVar()
        self.cntdisp = Message(font=('Sans',24),
                               textvariable=self.count)
        self.log = Button(text="Log Timestamp",
                          command=self.log_timestamp)
        self.quit = Button(text="Quit", command=sys.exit)
        self.tsdisp.pack(side=LEFT)
        self.cntdisp.pack()
        self.log.pack(side=TOP, expand=YES, fill=BOTH)
        self.quit.pack(side=BOTTOM, fill=BOTH)

    def log_timestamp(self):
        stamp = time.ctime()
        self.tsdisp.insert(END, stamp+"\n")
        self.tsdisp.see(END)
        self.tslist.append(stamp)
        self.count.set("% 3d" % len(self.tslist))

if __name__=='__main__':
    Logger().mainloop()

This Tk version uses the log_timestamp() method as the command= parameter for the button. In tkinter buttons are linked with a callback.

        self.log = Button(text="Log Timestamp",
                          command=self.log_timestamp)

That means on click, it calls that method.

PyQt example

In Python PyQt, you can implement the app like this:

import sys, time
from PyQt5.QtWidgets import QApplication, QWidget, QGridLayout, QTextEdit, QPushButton, QLabel, QHBoxLayout

class Logger(QWidget):
    def __init__(self, *args):
        QWidget.__init__(self, *args)
        self.layout = QGridLayout()
        self.layout.setColumnStretch(2,2)

        self.tsdisp = QTextEdit(self)
        self.tsdisp.setMinimumSize(250, 300)
        self.tscount = QLabel("", self)

        self.log = QPushButton("&Log Timestamp", self)
        self.quit = QPushButton("&Quit", self)

        self.layout.addWidget(self.tsdisp, 0, 0)
        self.layout.addWidget(self.tscount, 0, 1)
        self.layout.addWidget(self.log, 2, 0)
        self.layout.addWidget(self.quit, 2, 1)

        self.log.clicked.connect(self.log_timestamp)
        self.quit.clicked.connect(self.close)
        self.setLayout(self.layout)

    def log_timestamp(self):
        stamp = time.ctime()
        self.tsdisp.append(stamp)
        self.tscount.setText(str(self.tsdisp.toPlainText().count("\n")))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    logger = Logger()
    logger.show()
    sys.exit(app.exec_())

By creating the Layout Manager, the Logger class got to work. A layout manager is a complex topic in any GUI system, but Qt's implementation makes it simple.

In most cases, you will use Qt Designer to create a general GUI design, which can then be used to generate Python or C++ code. You can then make the generated code generate subclasses to add functionality.

But in this example, we choose to create the layout manager manually. The window building blocks are placed in individual cells of the grid layout, or can be placed across multiple cells.

self.layout = QGridLayout()
self.layout.setColumnStretch(2,2)
self.layout.addWidget(self.tsdisp, 0, 0)
...

The most interesting part of the app is where we connect the clicked signal to the function.

One button connects to the log_timestamp method; the other connects to the close method of the QWidget class.

self.log.clicked.connect(self.log_timestamp)
self.quit.clicked.connect(self.close)

Is Golang better than C?

threadspeed — Thu, 21 May 2020 18:10:12 +0000

Golang is like C if it was designed today. So what are the differences? In this article we'll discuss this.

C has been around for ages and Go is a new language that's only been around for around a decade. The similarities with C are:

Explicit in as many things
Minimal syntax.
Commonly done operations into the syntax.

Unlike C, Golang is:

is not a general-purpose language, but language to replace C++ for back-end server applications.
Go doesn’t have all the header file headaches of C
Has built-in support for concurrency using goroutines
Has a dedicated operator for turning off a bit: &^.
Doesn’t require odd, unreadable pointer syntax for function pointers.
Doesn’t require ; semicolons to end statements
Has declaration type inference.
Compromise between object-oriented programming and procedural
Has a garbage collector

It is much more pleasant to program in Go than in C.

But, Go isn’t really suitable for systems programming like OS kernels or device drivers. Nor is it suitable for embedded programming where you need direct realtime hardware access.

Which features does PyQt possess that Tkinter lacks?

threadspeed — Thu, 21 May 2020 16:07:44 +0000

Both PyQt and Tkinter are GUI modules for Python, but PyQt comes with additional features like networking, databases etc.

PyQt is a binding for Qt is probably the best cross-platform interface toolkit available right now, Tkinter may give you some troubles here.

If you don't know Python yet, you should learn Python before trying to make GUI apps with Python.

Look and feel

PyQt (Qt) is stable, mature, cross-platform and completely native. Tkinter generally looks like a few decades ago.

Take a look at these calculator applications, the first one in tkinter and the next one in pyqt.

Tkinter look and feel:

PyQt look and feel:

PyQt can adapt to the style of your operating system:

Widgets

For small apps Tkinter can be a good choice, but it comes with a limited number of widgets. PyQt comes with many widgets and a designer.

PyQt is supported by the Qt company, so it keeps getting more and more features. Tkinter has had the same number of widgets for over a decade.

Code

PyQt uses a signal-slot system that takes some time getting used to. Tk works on an old fashioned callback system.

For PyQt there's a lot more learning resources available than Tkinter. But it has a steeper learning curve, Tkinter is very small so easy to learn.

Here are some resources to learn PyQt:

To learn Tkinter:

What are some sites or books to learn PyQt?

threadspeed — Thu, 21 May 2020 15:23:38 +0000

PyQt has quite a hard learning curve. It lets you make desktop software with Python and comes with many widgets. If you are just starting with PyQt you can feel a bit overwhelmed. At the same time, its a useful skill to have for your career.

It's a very mature module that has been around for a long time. There is a lot of software developed with PyQt (Qt) so it makes sense to learn it. But where to start?

Learn PyQt

Here are some resources that help you learn Python PyQt.

The book and course Create Desktop Apps with Python PyQt5 gets you started very fast and is one of the most popular resources. It comes with many examples, videos and a lot more.

The site pythonbasics has many individual articles on PyQt programming. It goes over the various widgets and features of PyQt.

You can find more examples on pythonspot, on this pyqt site and this resource. These are all lose articles so you have to search around a bit to figure things out.

The Qt documentation is a good reference if you have experience with PyQt. Al though it is for C++ its still a useful reference when programming with PyQt because a lot of things overlap (PyQt is a binding for Qt)

Is PYQT hard to use for Python beginners?

threadspeed — Wed, 20 May 2020 17:41:22 +0000

No, it's quite user-friendly after you learned the Python basics. PyQt is a GUI module for Python.

There is lots of material to learn Pyqt, like this book or howto.

Unlike other GUI modules, PyQt comes with a designer program that lets you drag and drop your GUI elements on your window. You can then export it as .ui file and load it in Python.

So once you know the basics of Python, it's very easy to learn because there is a lot of training material and even a GUI designer. This makes it very easy to create desktop applications with Python.

In fact, there are many many tutorials for PyQt. Here is a short list of tutorials for creating a GUI with PyQt:

This is what the "hello world" app looks like with PyQt. If you know Python and objects/classes it's straight forward, but without knowing it can be hard to grasp.

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout                                                                
from PyQt5.QtCore import Qt                                                                                                                

class Window(QWidget):                                                                                                                     
    def __init__(self):                                                                                                                    
        QWidget.__init__(self)                                                                                                             
        self.button = QPushButton('Hello World', self)                                                                                     
        self.button.clicked.connect(self.handleButton)                                                                                     
        layout = QVBoxLayout(self)                                                                                                         
        layout.addWidget(self.button)                                                                                                      

    def handleButton(self):                                                                                                                
        print ('Hello World')                                                                                                              

if __name__ == '__main__':                                                                                                                 
    import sys                                                                                                                             
    app = QApplication(sys.argv)                                                                                                           
    window = Window()                                                                                                                      
    window.show()                                                                                                                          
    sys.exit(app.exec_())