from PyQt4 import QtCore
from PyQt4 import QtGui
from PyKDE4 import kdeui

class MyGUI(QtGui.QWidget):

    def __init__(self, parent=None):
        super(MyGUI, self).__init__(parent)
        self.pushbutton = kdeui.KPushButton()
        self.pushbutton.setText("Push me!")

        QObject.connect(self.pushbutton, QtCore.SIGNAL("clicked()"),
                               self.button_pushed)

    def button_pushed(self):
        print "Button clicked"

The main advantage of this syntax is that it’s very close to the C++ equivalent, and so you can translate easily from C++ to Python. Unfortunately the advantages of this syntax end here. The disadvantages, at least from a Python coding perspective, outweigh the advantages:

• It’s extremely error-prone: make a typo, and not only your signal won’t be connected, but you won’t even get a warning, your program will simply do nothing;
• In case you have overloaded signals, you have to type the exact signature, going back to the first problem;
• It’s not Pythonic at all.

So, in recent PyQt versions (and thus also in PyKDE4) a new style approach was introduced (although the old style is always present should it be the need to). Using the new style, the signals become a property of the object that emits them. and then you use the connect function of that property. Here’s the example using the new style-signals:

from PyQt4 import QtCore
from PyQt4 import QtGui
from PyKDE4 import kdeui

class MyGUI(QtGui.QWidget):

    def __init__(self, parent=None):
        super(MyGUI, self).__init__(parent)
        self.pushbutton = kdeui.KPushButton()
        self.pushbutton.setText("Push me!")
        # New style
        self.pushbutton.clicked.connect(self.button_pushed)

    def button_pushed(self):
        print "Button clicked"

As you can see it’s much clearer, and much more Pythonic. Also, typos will trigger an AttributeError, which means you’ll be able to track where the problem is.

What about overloaded signals? Normally the first defined is the default, but you can use a dictionary-like syntax to access other overloads (signal names are completely made up here):

# One signal is without arguments, the other has a bool

# Signal without arguments
self.my_widget.connected.connect(self.handle_errors)
# Signal with a book
self.my_widget.connected[bool].connect(self.handle_errors)

Signals are emitted with the emit() function and disconnected with the disconnect() function:

# Emit a signal
self.pushbutton.clicked.emit()
# Emit a signal with a value (an int)
self.my_widget.valueChanged.emit(int)
# Disconnect another
self.my_tabwidget.currentIndexChanged.disconnect()

To define new signals, you can use the pyqtSignal function, specifying which values will the signal take (if any): just define that as a class constant (like in the example) and then you can access them like the wrapped ones:

class MyWidget(QWidget):

    # Signal with no arguments
    operationPerformed = QtCore.pyqtSignal()

    # Signal that takes arguments
    valueChanged = QtCore.pyqtSignal(int)

I merely scratched the surface with this. For more information, check out PyQt’s reference manual, which also covers other cases.

Aside that, I put a contact form on this blog. It may be useful for reports that aren’t directly related to the posts.

In this new version there have been a few improvements and correction to a couple bugs (for example saveMatrix did not really save) and the start (only a stub at the moment) of an append function to add more columns (I’ll also think about a function to add rows).

DataMatrix is licensed under the GNU GPL, version 2 only. You can download the installer (Windows) or the source distribution (Linux and other *nixes). The only requirement is Python 2.5 or later installed on your system.

The README currently is a stub, but you can browse the pydoc generated documentation, which details how to instantiate and use DataMatrix objects (or you can turn to my older post).

Also, since git is the new “cool feature of the day”, DataMatrix is is hosted on github’s repository, and you can grab the source with

git clone git://github.com/cswegger/datamatrix.git

Comments and suggestions are welcome. I’ll be putting a static page on DataMatrix tomorrow, if time permits.

The idea is to store the values of the text file as a dictionary of columns which includes then a list of (row name, row value) tuples. Like this, you can access the columns by their name (I need to see if it’s workable to also use numbers), or you can view specific rows, including all or a subset of the columns. It’s decently faster and it allows for non-sequential access, which you can’t do when reading a file (or a file-like structure).

Requirements

I have tested this on Python 2.5.1. Older versions may or may not work. All modules called by this one should be shipped with Python itself.

Download and installation

Download the py file directly. Currently there is no installation mechanism, so copy it wherever Python can find it.  There’s some API documentation generated with pydoc.

This module is licensed under the GNU General Public License, version 2.

Usage

First of all, import the module

import datamatrix

Then open a file and instantiate a DataMatrix object

fh = open("somefile.txt")
data = datamatrix.DataMatrix(fh)

By default no column with row names is specified, so if you have one, you have to specify it:

data = datamatrix.DataMatrix(fh, row_names=1)

More options are in the documentation.

Once the DataMatrix is initialized, you can view how many columns are there and also view rows with the getRow method:

>> data.columns
["GeneID","Great_Exp1","Great_Exp2"]

>> data["Great_Exp1"]
[("Gene1",56.34),
...
]

>> data.getRow(5)
["NOT_EXISTENT","56.545","4.56"]

Sometimes you’d want to get only the column without the row identifier, and that’s where getColumn comes in:

>> data.getColumn("Great_Exp1")
[56.34,2.55.....]

Should you want to save a DataMatrix instance, you can use the writeMatrix function:

datamatrix.writeMatrix(data,fname="/path/to/somewhere/file.txt")

That’s all. Questions and suggestions, especially on coding and improvements, are very welcome.

My question, directed to whoever has experience with QSql and the Python DB-API, is: what are the advantages of one approach to the other? I’m leaning towards DB-API because like that I can create modules which work also in command line applications.