BlogJava-杂家杂谈-随笔分类-Python

Django on Jython

glorywine — Tue, 16 Sep 2008 16:41:00 GMT

   使用Django已经一段时间了，非常喜欢这样的状态，很少的配置文件和代码，就可以样一个原型跑起来。1.0已经发布一段时间了，有了很多的改变，改进，很吸引眼球。但是还有一个特性非常吸引我，Django可以运行在Jython上了，这就意味着，可以在Tomcat,Glassfish等服务器上跑Django了，EXCITING?

   OK, Let's give a shot!
   1. of course, 先要现在Django，不过我还是推荐使用svn中的代码。

svn co http://code.djangoproject.com/svn/django/trunk/ django-dev

2. 接着就要下载Jython了，当前的stable版本是2.2.1，而我们需要的是2.5，该版本还是alpha阶段，所以，还是从svn中获取。

svn co https://jython.svn.sourceforge.net/svnroot/jython/trunk/jython/ jython-dev

完成了Jython的检出，开始编译工作。需要指出的是，我们在这里使用ant来构建Jython，当然，也可以选择maven，看个人习惯了，ant和maven的具体安装方法大家可以去google，这里不再累述。

cd jython-dev
ant

   稍等片刻，就可以完成编译工作了，生成的文件在jython-dev下的dist文件夹下。然后，我将dist下的文件全部拷贝到D:/jython下，我在这里使用的是windows，大家可以根据自己的平台进行设置。
   为了能在console里使用Jython，我们还需要将jython目录下的bin文件夹添加到path。这里大家也可以去google，不再多说。现在打开一个console，输入jython，是不是能看到非常熟悉的，python控制台呢？
   3. 好的，现在就需要安装Django了。

cd django-dev
jython setup.py build
jython setup.py install

安装完成后，就可以在jython/Lib/site-packages下看到Django了。为了查看是否安装成功，使用下面的方法。打开控制台：

D:\>jython
Jython 2.5a3+ (trunk, ???? 16 2008, 18:50:22)
[Java HotSpot(TM) Client VM (Sun Microsystems Inc.)] on java1.6.0_10-beta
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>> django.get_version()
u'1.0-post-release-SVN-SVN-unknown'

如果看到了最后的输出就表示安装成功了。
4. 当前Django on Jython只支持postgresql，所以，我们这里还需要下载一个Lib，Django-Jython.

svn co http://django-jython.googlecode.com/svn/trunk/ django-jython
cd django-jython
jython setup.py build
jython setup.py install

   这样就完成了django-jython的安装。
   5. 最后就是安装postgresql数据库了，大家可以根据官方的文档进行安装。

   万事俱备，让我们开始真正的Django on Jython之旅吧。
   这里还需要说明一点，在完成Django的安装之后，在jython/bin下会有一个django-admin.py，这个是Django命令的工具，为了同CPython下的Django进行区别，我在这里将其重命名为django-admin-jy.py。
   好，切换到工作目录。

django-admin-jy.py startproject djangonjython

是不是有djangonjython这个目录出现呢？对了，这就是我们创建的工程。
如果你是一个急性子，那么就让我们尝试一下，看看是不是能够运行呢？

cd djangonjython
jython manage.py runserver

熟悉的页面是否出现呢？

在观察一下djangonjython目录里的文件，哈，没有了.pyc，改成了.class，确实是jython在工作了。
如果只是运行这么一个东西，肯定就没有什么价值了。OK，let's build an application。我们在这里创建一个简单的blog（老生常谈了:)）。

jython manage.py startapp blog

这样就完成了app的创建，当然在djangonjython下应该多了一个blog文件夹，里面还包含了一些文件。
首先修改models.py，内容如下：

1 from django.db import models
2 from django.contrib.auth.models import User
3
4 class Entry(models.Model):
5     STATUS_CHOICES = (
6         (0, 'live'),
7         (1, 'draft'),
8         (2, 'cancel'),
9     )
10     author = models.ForeignKey(User)
11     title = models.CharField(max_length=255)
12     slug = models.SlugField()
13     content = models.TextField()
14     create_at = models.DateTimeField(auto_now_add=True)
15     status = models.IntegerField(default=0, choices=STATUS_CHOICES)
16
17     def __unicode__(self):
18         return self.title
19
20     def get_absolute_url(self):
21         return '/blog/%s' % (self.slug)
22
23     class Meta:
24         ordering = ['-create_at']

这只是一个非常简单的原型，说明问题就行了。好，既然使用了Django 1.0那么就要有一些改变，现在的Django使用了newform-admin，那么就在blog目录下创建admin.py文件，内容如下：

1 from django.contrib import admin
2
3 from djangonjython.blog.models import Entry
4
5 class EntryAdmin(admin.ModelAdmin):
6     list_display = ('title', 'author', 'create_at', 'status',)
7     ordering = ['-create_at']
8     list_filter = ('author', 'status',)
9     prepopulated_fields = {'slug': ('title',),}
10
11 admin.site.register(Entry, EntryAdmin)

   这样就将Entry注册到了admin site里，就可以在admin page里进行管理了。
   再进一步之前，先启动先前安装的postgresql，创建database blog。完成之后，就要对项目进行一些配置了。
   首先是djangonjython目录下的urls.py
   取消这几行的注释：

from django.contrib import admin
admin.autodiscover()

(r'^admin/(.*)', admin.site.root),

为的是能够访问到admin page.
接着是settings.py，

DATABASE_ENGINE = 'doj.backends.zxjdbc.postgresql'           # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
DATABASE_NAME = 'blog'             # Or path to database file if using sqlite3.
DATABASE_USER = 'yourname'             # Not used with sqlite3.
DATABASE_PASSWORD = 'yourpassword'         # Not used with sqlite3.
DATABASE_HOST = ''             # Set to empty string for localhost. Not used with sqlite3.
DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.admin',
    'djangonjython.blog',
    'doj',
)

   对上面的代买进行一些说明：
   doj.backends.zxjdbc.postgresql是之前安装的django-jython提供的数据支持，当然，要使用这个，必须将doj这个库添加到PYTHONPATH中，所以在下面的INSTALLED_APPS里，加入了doj，而djangonjyton.blog就是之前创建的app。
   好，完成了这些，就可以开始数据库的创建了。熟悉的命令：

jython manage.py syncdb

   按照上面的提示，一步一步的进行填写。完成之后，启动服务，是不是又是一个熟悉的画面？
   填写之前要求的管理员用户名和密码，就进入到了admin page，我习惯称后台管理页面。
   好了，在这里就可以添加一些entry了。完成了后台的管理，让我们添加一些前台的显示吧。
   在这里，我打算使用django自带的generic views，使用起来非常的简单。为了同项目的urls.py区别开，在blog下创建一个新的urls.py，内容如下：

1 from django.conf.urls.defaults import *
2
3 from djangonjython.blog.models import Entry
4
5 entry_dict = {
6     'queryset': Entry.objects.all(),
7     'template_object_name': 'entry',
8 }
9
10 urlpatterns = patterns('django.views.generic.list_detail',
11     (r'^blog/$', 'object_list', entry_dict),
12     (r'^blog/(?P.*)/$', 'object_detail', entry_dict),
13 )
14

然后就要修改项目目录下的urls.py了，在(r'^admin/(.*)', admin.site.root)之前添加：

(r'', include('djangonjython.blog.urls')),

接着就要添加模板文件了，在blog目录下创建templates/blog这样的目录，然后再里面添加entry_list.html和entry_detail.html两个文件，内容分别如下：
entry_list.html

1 {% if entry_list %}
2     {% for entry in entry_list %}
3         <a href="/blog/{{ entry.slug }}"><h3>{{ entry.title }}h3>a> Post at: {{ entry.create_at|date:"Y-b-d" }}<hr/>
4     {% endfor %}
5 {% endif %}

entry_detail.html

1 {% if entry %}
2     <span style="color: green;">{{ entry.title }}span><br/><br/>
3     post by: <b>{{ entry.author.username }}b><br/><br/>
4     <div style="color: blue">{{ entry.content|safe }}div>
5 {% endif %}

完成了这些之后，就要告诉django，怎么处理了，也就是要修改settings.py了：

import os
PROJECT_ROOT = os.path.abspath(__file__)
TEMPLATE_DIRS = (
os.path.join(PROJECT_ROOT, 'blog/templates'),
)

   添加前面两句，修改后面的TEMPLATE_DIRS，告诉django到哪里去找模板文件。
   重新启动服务器，输入http://localhost:8000/blog/，就可以看到一个简单的blog列表了，如果有的话。点击相应的标题，就会进入到具体的entry了。
   到这里位置，一个简单的blog就算是创建好了。我们的目的主要是要看他在其他的服务器上是否能够运行，好的，这里就要进行打包处理了。
   django-jython提供了一个war命令，会将我们的工程打包成war包，方便部署。不过django-jython有一个小小的bug。找到jython/Lib/site-packages/doj/manamgement/commands/war.py，在该文件的第228行，原来是：

if dest_relative_path[-1] == '/':

现在我们要将其改为：

if dest_relative_path[-1] == os.path.sep:

因为在windows下得到的是'\\'而不是'/'，所以执行的时候会出错，可能开发者没有在windows下进行测试，所以出现了这样的情况。
接着，我们需要链接postgresql的jdbc包，大家可以在这里下载postgres-jdbc。下载后，将其放在项目目录下，开始打包：

jython manage.py war --include-java-libs=./postgresql-8.3-603.jdbc4.jar

   过一段时间，就可以在项目的上一级目录看到djangonjython.war
   到这里，java程序员就可以使用熟悉的java web server进行部署了！部署完成后，输入http://localhost:8080/djangonjython/blog/就可以进行访问了。
   这里给出一些在tomcat上运行的截图：

怎么样，感觉还是不错吧。
其实，Django on Jython还有很长的路要走，要支持更多的主流数据库，以及运行效率等问题。不过还是非常期待，希望能够快速的发展，毕竟Django的开发效率要远远高于Java。So let's look forward to it!

glorywine 2008-09-17 00:41 发表评论

Django Docs

glorywine — Sun, 24 Aug 2008 07:17:00 GMT

       做Django开发, 经常需要查看docs, 这就需要我到官网上去浏览. 如果遇到网络不好, 页面打开十分缓慢, 非常痛苦.
       其实, 在django的svn repository里, 有相应的docs, 不过是txt格式的. 如果浏览这个, 当然会非常的别扭.
       今天看到, django对docs进行了重构, 现在大家可以将这些文件下载到本地, 然后进行编译, 生成相应的文档, 浏览起来会非常方便, 舒服.

       好, 我们简单的看一看该如何操作:
1. 从svn库中checkout:

svn co http://code.djangoproject.com/svn/django/trunk/docs/ django_docs

这样, 在当前目录下就会有了django_docs了. 进去看一看, 恩, 重构后结构果然清晰多了, 过去是一股脑将所有的文件放在一起, 现在是分门别类, 不错.

2. 安装Sphinx:

easy_install Sphinx

当然前提是python中已经安装了easy_install, 如果没有, 大家google一下, 非常容易.
熟悉python的朋友应该知道, Sphinx是非常好的一个工具, 可以将简单文本格式转换为html格式, 当然, 文本内容需要按照Sphinx的语法进行编写. Python现在的在线documents就是使用Sphinx进行编译的.感兴趣的朋友可以到Sphinx了解更多内容.

3. 编译:

make html

        这里make提供了很多种格式, 因为我们只需要html, 所以加上这个选项就行了.
        到这里, 就完成了django_docs的编译工作, 在django_docs/_build/html下就是编译的结果. 重构后的文档的css也有了新的变化, 现在的非常像django_book的样式.
        OK, 以后我们就可以在本地进行文档的阅读了, 相信会给开发带来事半功倍的效果.

        这里我附上一份我编译好的, 供大家下载. django_docs

glorywine 2008-08-24 15:17 发表评论

PyQt4 - (4) 布局管理

glorywine — Wed, 30 Jul 2008 07:39:00 GMT

PyQt4中的布局管理

布局是GUI程序开发中非常重要的一个环节, 而布局管理就是要规划如何在窗口中放置需要的部件. PyQt4中就有两种方法来完成布局任务,一个是绝对位置(absolute positioning), 另一个就是使用布局类(layout classes).

绝对位置(absolute positioning)
这种方法就需要程序员在程序中指定每个部件的坐标位置和大小. 在这里有几个注意事项.

指定了坐标和大小的部件是不能够随着窗口大小的变化而变化的.
程序在不同的操作系统平台上也许会有所变化.
改变字体可能会引起布局的混乱.
如果需要改变当前的布局, 就需要重新编码, 这意味着非常大的工作量.

1 #!/usr/bin/python
2
3 # absolute.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class Absolute(QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setWindowTitle('Communication')
13
14         label = QtGui.QLabel('Could\'t', self)
15         label.move(15, 10)
16
17         label = QtGui.QLabel('care', self)
18         label.move(35, 40)
19
20         label = QtGui.QLabel('less', self)
21         label.move(55, 65)
22
23         label = QtGui.QLabel('And', self)
24         label.move(115, 65)
25
26         label = QtGui.QLabel('then', self)
27         label.move(135, 45)
28
29         label = QtGui.QLabel('you', self)
30         label.move(115, 25)
31
32         label = QtGui.QLabel('kissed', self)
33         label.move(145, 10)
34
35         label = QtGui.QLabel('me', self)
36         label.move(215, 10)
37
38         self.resize(250, 150)
39
40 app = QtGui.QApplication(sys.argv)
41 qb = Absolute()
42 qb.show()
43 sys.exit(app.exec_())

在这里, 就是简单的调用move()方法来指定部件的放置坐标. 坐标的顶点就在窗口的左上角, x由左向右不断增大, y由上到下不断增大.

Figure: absolute positioning

Box Layout

使用布局类进行布局管理是一件非常轻松的事情. 最基本的布局类就是QHboxLayout和VHBoxLayout. 他们将部件线性的水平或垂直排列.
这里假设我们要将两个按钮放在窗口的右下方, 要实现这样的布局, 使用一个QHBoxLayout和一个QVBoxLayout, 而其他的空间, 通过添加stretch factor来实现.

1 #!/usr/bin/python
2
3 # boxlayout.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class BoxLayout (QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setWindowTitle('boxlayout')
13
14         ok = QtGui.QPushButton('OK')
15         cancel = QtGui.QPushButton('Cancel')
16
17         hbox = QtGui.QHBoxLayout()
18         hbox.addStretch(1)
19         hbox.addWidget(ok)
20         hbox.addWidget(cancel)
21
22         vbox = QtGui.QVBoxLayout()
23         vbox.addStretch(1)
24         vbox.addLayout(hbox)
25
26         self.setLayout(vbox)
27
28         self.resize(300, 150)
29
30 app = QtGui.QApplication(sys.argv)
31 qb = BoxLayout()
32 qb.show()
33 sys.exit(app.exec_())

ok = QtGui.QPushButton( ' OK ' )
cancel = QtGui.QPushButton( ' Cancel ' )

创建两个按钮

hbox = QtGui.QHBoxLayout()
hbox.addStretch( 1 )
hbox.addWidget(ok)
hbox.addWidget(cancel)

创建一个水平的box layout. 然后添加stretch factor和两个按钮.

vbox = QtGui.QVBoxLayout()
vbox.addStretch( 1 )
vbox.addLayout(hbox)

创建最后的布局类, 将水平的布局类放入到垂直的布局类当中.

self.setLayout(vbox)

最后, 将窗口的布局设定为垂直布局.

Figure: box layout

QGridLayout

最常用的布局类应当是QGridLayout, 他将窗口分成不同的行和列.

1 #!/usr/bin/python
2
3 # gridlayout.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class GridLayout(QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setWindowTitle('grid layout')
13
14         names = ['Cls', 'Bck', '', 'Close', '7', '8', '9', '/',
15                  '4', '5', '6', '*', '1', '2', '3', '-',
16                  '0', '.', '=', '+']
17
18         grid = QtGui.QGridLayout()
19
20         j = 0
21         pos = [
22             (0, 0), (0, 1), (0, 2), (0, 3),
23             (1, 0), (1, 1), (1, 2), (1, 3),
24             (2, 0), (2, 1), (2, 2), (2, 3),
25             (3, 0), (3, 1), (3, 2), (3, 3),
26             (4, 0), (4, 1), (4, 2), (4, 3)
27             ]
28
29         for i in names:
30             button = QtGui.QPushButton(i)
31             if j == 2:
32                 grid.addWidget(QtGui.QLabel(''), 0, 2)
33             else:
34                 grid.addWidget(button, pos[j][0], pos[j][1])
35             j = j + 1
36
37         self.setLayout(grid)
38
39 app = QtGui.QApplication(sys.argv)
40 qb = GridLayout()
41 qb.show()
42 sys.exit(app.exec_())

在这个例子中, 创建了很多按钮, 用来填充相应的grid.

grid = QtGui.QGridLayout()

这一句就创建了grid layout.

if j == 2 :
grid = addWidget(QtGui.QLabel( '' ), 0, 2 )
else :
grid = addWidget(button, pos[j][0], pos[j][i])

把部件放入grid, 调用addWidget()方法就行了, 参数就是要放入的部件以及相应的行数和列数.

Figure: grid layout

需要说明一下, 部件也可以多行和多列. 下面的列子就演示了之一点.

1 #!/usr/bin/python
2
3 # gridlayout2.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class GridLayout2(QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setWindowTitle('grid layout2')
13
14         title = QtGui.QLabel('Title')
15         author = QtGui.QLabel('Author')
16         review = QtGui.QLabel('Review')
17
18         titleEdit = QtGui.QLineEdit()
19         authorEdit = QtGui.QLineEdit()
20         reviewEdit = QtGui.QTextEdit()
21
22         grid = QtGui.QGridLayout()
23         grid.setSpacing(10)
24
25         grid.addWidget(title, 1, 0)
26         grid.addWidget(titleEdit, 1, 1)
27
28         grid.addWidget(author, 2, 0)
29         grid.addWidget(authorEdit, 2, 1)
30
31         grid.addWidget(review, 3, 0)
32         grid.addWidget(reviewEdit, 3, 1, 5, 1)
33
34         self.setLayout(grid)
35         self.resize(350, 300)
36
37 app = QtGui.QApplication(sys.argv)
38 qb = GridLayout2()
39 qb.show()
40 sys.exit(app.exec_())
41

grid = QtGui.QGridLayout()
grid.setSpacing( 10 )

创建布局类, 并设定部件之间的距离为10个像素.

grid.addWidget(reviewEdit, 3 , 1 , 5 , , 1 )

给布局中添加部件时, 可以指定占据的行数和占据的列数. 这个例子中, 我们让reviewEdit占据了5行.

Figure: grid layout 2

glorywine 2008-07-30 15:39 发表评论

PyQt4 - (3) 菜单和工具栏

glorywine — Sat, 26 Jul 2008 04:08:00 GMT

主窗口
QMainWindow类给我们提供了一个程序主窗口，使得我们能够创建一个标准的程序框架，包括了状态栏，工具栏和菜单栏。

状态栏(Statusbar)
状态栏就是一种用来显示状态信息的小部件.

1 #!/usr/bin/python
2
3 # statusbar.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class MainWindow(QtGui.QMainWindow):
9     def __init__(self):
10         QtGui.QMainWindow.__init__(self)
11
12         self.resize(250, 150)
13         self.setWindowTitle('statusbar')
14
15         self.statusBar().showMessage('Ready')
16
17 app = QtGui.QApplication(sys.argv)
18 main = MainWindow()
19 main.show()
20 sys.exit(app.exec_())
21

self.statusBar().showMessage( ' Ready ' )

这里需要注意的就是这一句,通过调用QMainWindow类的statusBar()方法,得到statusbar的句柄,然后调用showMessage()显示信息在statusbar上.非常容易吧!

菜单栏(Menubar)
菜单是应用程序中最常见的一种组件.通常每个菜单都是完成不同的任务.

1 #!/usr/bin/python
2
3 # menubar.py
4
5 import sys
6 from PyQt4 import QtGui, QtCore
7
8 class MainWindow(QtGui.QMainWindow):
9     def __init__(self):
10         QtGui.QMainWindow.__init__(self)
11
12         self.resize(250, 150)
13         self.setWindowTitle('menubar')
14
15         exit = QtGui.QAction(QtGui.QIcon('icons/web.png'), 'Exit', self)
16         exit.setShortcut('Ctrl+Q')
17         exit.setStatusTip('Exit application')
18         self.connect(exit, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))
19
20         self.statusBar()
21
22         menubar = self.menuBar()
23         file = menubar.addMenu('&File')
24         file.addAction(exit)
25
26 app = QtGui.QApplication(sys.argv)
27 main = MainWindow()
28 main.show()
29 sys.exit(app.exec_())
30

menubar = self.menuBar()
file = menubar.addMenu( ' &File ' )
file.addAction(exit)

首先调用self.menuBar()创建菜单栏,接着调用addMenu()添加一个菜单,最后给菜单添加一个动作,就是这里的exit.

工具栏(Toolbar)
菜单可以将不同的命令按组分类,然而,有些常用的命令就可以通过工具栏来放置,这样更便于使用.

1 #!/usr/bin/python
2
3 # toolbar.py
4
5 import sys
6 from PyQt4 import QtGui, QtCore
7
8 class MainWindow(QtGui.QMainWindow):
9     def __init__(self):
10         QtGui.QMainWindow.__init__(self)
11
12         self.resize(250, 150)
13         self.setWindowTitle('toolbar')
14
15         self.exit = QtGui.QAction(QtGui.QIcon('icons/web.png'), 'Exit', self)
16         self.exit.setShortcut('Ctrl+Q')
17         self.connect(self.exit, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))
18
19         self.toolbar = self.addToolBar('Exit')
20         self.toolbar.addAction(self.exit)
21
22 app = QtGui.QApplication(sys.argv)
23 main = MainWindow()
24 main.show()
25 sys.exit(app.exec_())

self.exit = QtGui.QAction(QtGui.QIcon( ' icons/web.png ' ), ' Exit ' , self)
self.exit.setShortcut( ' Ctrl+Q ' )

GUI程序是通过命令来控制的, 而这些命令可以由菜单,上下文菜单,工具栏或者快捷键来发出. PyQt将命令抽象为actions. 一个action对象可以有text, 图标, 快捷键, 状态栏描述, "What's This?"描述和tooltip. 上面的例子,就定义了icon, tooltip和shortcut.

self.connect(self.exit, QtCore.SIGNAL( ' triggered() ' ), QtCore.SLOT( ' close() ' ))

这一句,将action的triggered()信号和预先定义的close()槽结合到一起.

self.toolbar = self.addToolBar( ' Exit ' )
self.toolbar.addAction(self.exit)

然后就将定义好的action放入toolbar就可以了.

Figure: toolbar

一个完整的程序
最后这个部分,将menubar, toolbar和statusbar放在一起.

1 #!/usr/bin/python
2
3 # mainwindow.py
4
5 import sys
6 from PyQt4 import QtGui, QtCore
7
8 class MainWindow(QtGui.QMainWindow):
9     def __init__(self):
10         QtGui.QMainWindow.__init__(self)
11
12         self.resize(350, 250)
13         self.setWindowTitle('mainwindow')
14
15         textEdit = QtGui.QTextEdit()
16         self.setCentralWidget(textEdit)
17
18         exit = QtGui.QAction(QtGui.QIcon('icons/web.png'), 'Exit', self)
19         exit.setShortcut('Ctrl+Q')
20         exit.setStatusTip('Exit application')
21         self.connect(exit, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))
22
23         self.statusBar()
24
25         menubar = self.menuBar()
26         file = menubar.addMenu('&File')
27         file.addAction(exit)
28
29         toolbar = self.addToolBar('Exit')
30         toolbar.addAction(exit)
31
32 app = QtGui.QApplication(sys.argv)
33 main = MainWindow()
34 main.show()
35 sys.exit(app.exec_())
36

textEdit = QtGui.QTextEdit()
self.setCentralWidget(textEdit)

这里创建了一个edit部件,并将其设置为QMainWindow的中央部件.中央部件就是说要占据初菜单,工具栏,状态栏之外的所有空间.

glorywine 2008-07-26 12:08 发表评论

PyQt4 - (2) 第一印象

glorywine — Sat, 21 Jun 2008 15:58:00 GMT

在这个部分，我们开始学习一些PyQt4的基本功能，解释会比较详细，就像教孩子说话一样。

最简单的example

下面的示例会非常的简单，仅仅显示一个小窗口，但是将来我们可以通过这个小窗口做很多事情。我们可以对它进行缩放，最大化，最小化。而这些就需要比较多的代码了。但是开发人员已经帮我们完成了这些功能，因为这些功能在大多场合都会使用到，所以没有必要让我们重复。PyQt是一个高级别的工具库，如果使用级别相对较低的库开发下面的功能，就非常可能需要更多的代码了。

1#!/usr/bin/python
2
3# simple.py
4
5import sys
6from PyQt4 import QtGui
7
8app = QtGui.QApplication(sys.argv)
9
10widget = QtGui.QWidget()
11widget.resize(250, 150)
12widget.setWindowTitle('simple')
13widget.show()
14
15sys.exit(app.exec_())

下面对代码进行分析

import sys
from PyQt4 import QtGui

这里，我们导入了必要的模块，PyQt4的基本模块都在QtGui中。

app = QtGui.QApplication(sys.argv)

每一个PyQt4程序都必须创建一个application对象，application类位于QtGui模块中。sys.argv传入命令行参数。Python脚本可以通过shell运行，这样我们就可以对程序的启动进行控制。

widget = QtGui.QWidget()

QWidget是PyQt4中所有用户接口对象的基类，我们使用QWidget默认的构造方法来创建QWidget对象，默认的构造方法没有指定父控件，如果一个widget没有指定父控件，那么我们就称他为一个window。

widget.resize(250, 150)

resize()方法调整widget的大小，在这里我们设定宽度为250px，高度为150px。

widget.setWindowTitle('simple')

setWindowTitle()方法设置了窗口的title，title在titlebar中显示。

widget.show()

调用show()方法将窗口显示出来。

sys.exit(app.exec_())

最后，就会进入application的事件循环。事件处理就从这里开始，循环不断的从窗口接受需要处理的事件，然后将其分发给相应的时间处理方法。通过调用exit()方法或者销毁widget来终止事件循环，调用sys.exit()方法确保了程序可以明确的退出，也就是程序退出后会告知系统。
也许你会问，为什么exec_()方法最后会有一个下划线？问得非常好，这完全是因为exec是python的一个关键字，所以我们不得不使用exec_来代替。

图1：simple

添加图标

应用程序的图标一般就是一个在程序标题栏左上角显示的小图片，下面的例子我们展示如何使用PyQt4来显示图标，同时引入一些新的方法。

1 #!/usr/bin/python
2
3 # icon.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class Icon(QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setGeometry(300, 300, 250, 150)
13         self.setWindowTitle('Icon')
14         self.setWindowIcon(QtGui.QIcon('icons/web.png'))
15
16 app = QtGui.QApplication(sys.argv)
17 icon = Icon()
18 icon.show()
19 sys.exit(app.exec_())

程序使用的是类似C语言的过程式风格，Python同时支持过程式和面向对象式的编程风格。需要注意的是，在使用PyQt4时，意味着面向对象编程。

class Icon(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)

面向对象编程中最重要的三个要素就是类(classes),数据(data)和方法(methods)。首先我们建立一个类叫做Icon，他从QtGui.QWidget继承而来。这就意味着，我们必须要两次调用构造方法，一个是Icon类的，另一个是父类的。

self.setGeometry(300, 300, 250, 150)
self.setWindowTitle('Icon') self.setWindowIcon(QtGui.QIcon('icons/web.png'))

上面三个方法都是从父类继承而来，即QtGui.QWidget。setGeometry()在这里做两件事情，一是指定了窗口在屏幕中的位置，二就是指定了窗口的大小。前面两个参数是x和y坐标，后面两个是窗口的width和height。最后一个方法给窗口指定了一个图标，我们需要首先创建一个QIcon对象，而QIcon接受一个参数指明图标的路径。

图2：Icon

展示信息提示(tooltip)

我们可以使用PyQt4给任何的部件添加信息提示功能。

1 #!/usr/bin/python
2
3 # tooltip.py
4
5 import sys
6 from PyQt4 import QtGui
7 from PyQt4 import QtCore
8
9 class Tooltip(QtGui.QWidget):
10     def __init__(self, parent=None):
11         QtGui.QWidget.__init__(self, parent)
12
13         self.setGeometry(300, 300, 250, 150)
14         self.setWindowTitle('Tooltip')
15
16         self.setToolTip('This is a QWidget widget')
17         QtGui.QToolTip.setFont(QtGui.QFont('OldEnglish', 10))
18
19 app = QtGui.QApplication(sys.argv)
20 tooltip = Tooltip()
21 tooltip.show()
22 app.exec_()

在这个例子中，我们给QWidget提供了信息提示。

self.setToolTip('This is a QWidget widget')

使用setTooltip()来创建一个tooltip，值得高兴的是，我们可以使用富文本格式(rich text formatting)。

QtGui.QToolTip.setFont(QtGui.QFont('Courier New', 10))

    由于QToolTip默认的字体看起来很糟糕，所以我们对之进行一些改进。

图3：Tooltip

关闭窗口

    之前的例子中，我们关闭程序都是使用标题栏上的X按钮进行关闭的。下面的例子里，我们使用编程的方式来关闭窗口。而在这里，我们就要开始了解一些Qt中非常重要的概念了，信号(signals)和槽(slots)。
    下面一行是QPushButton的构造方法。

QPushButton(string text, QWidget parent = None)

参数text是在按钮上显示的文本，parent是按钮的父容器。

1 #!/usr/bin/python
2
3 # quitbutton.py
4
5 import sys
6 from PyQt4 import QtGui, QtCore
7
8 class QuitButton(QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setGeometry(300, 300, 250, 150)
13         self.setWindowTitle('Icon')
14
15         quit = QtGui.QPushButton('Close', self)
16         quit.setGeometry(10, 10, 60, 35)
17
18         self.connect(quit, QtCore.SIGNAL('clicked()'), \
19                      QtGui.qApp, QtCore.SLOT('quit()'))
20
21 app = QtGui.QApplication(sys.argv)
22 qb = QuitButton()
23 qb.show()
24 sys.exit(app.exec_())

quit = QtGui.QPushButton('Close', self)
quit.setGeometry(10, 10, 60, 35)

在QWidget上我们创建了一个按钮，就像在屏幕中创建一个QWidget一样。

self.connect(quit, QtCore.SIGNAL('clicked()'), \
QtGui.qApp, QtCore.SLOT('quit()'))

正如前面所说，PyQt4的事件处理时间里在信号(signals)和槽(slots)机制上的。如果我们点击了按钮，就发射了信号clicked()方法。槽可以是PyQt槽，也可以是任何python中可调用的方法。通过使用QtCore.QObject.connect()方法将信号和槽链接起来。在我们的例子中，使用的槽是PyQt中预先定义的quit()槽。就好象sender和receiver一样，在两个对象之间进行交流。在上面的例子里，sender就是按钮，receiver就是application对象。

图4：quit button

对话框

默认情况下，如果我们点击了标题栏的X按钮，就会将窗口关闭，而有些时候，需要修改这样的行为。比如说在文本编辑器中，如个要关闭一个正在修改的文件，就会弹出一个对话框来确认。

1 #!/usr/bin/python
2
3 # messagebox.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class MessageBox(QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setGeometry(300, 300, 250, 150)
13         self.setWindowTitle('message box')
14
15     def closeEvent(self, event):
16         reply = QtGui.QMessageBox.question(self, 'Message', \
17                                            'Are you sure to quit?',\
18                                            QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
19         if reply == QtGui.QMessageBox.Yes:
20             event.accept()
21         else:
22             event.ignore()
23
24
25 app = QtGui.QApplication(sys.argv)
26 mb = MessageBox()
27 mb.show()
28 sys.exit(app.exec_())

如果要关闭QWidget，QCloseEvent时间就会产生。要修改QWidget的默认行为，就需要重载父类中的closeEvent()方法。

reply = QtGui.QMessageBox.question(self, 'Message', \
'Are you sure to quit?',\
QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)

在这里，显示了两个按钮的对话框，Yes和No。第一个string参数出现在标题栏上，第二个string参数显示在对话框中。在reply中保存了返回值。

if reply == QtGui.QMessageBox.Yes:
event.accept()
else:
event.ignore()

对返回值进行比较，如果点击了Yes按钮，就接受事件，关闭窗口，相反就忽略事件。

图5：message box

窗口居中

下面的代码展示了如何将创建的窗口在屏幕中居中。

1 #!/usr/bin/python
2
3 # center.py
4
5 import sys
6 from PyQt4 import QtGui
7
8 class Center(QtGui.QWidget):
9     def __init__(self, parent=None):
10         QtGui.QWidget.__init__(self, parent)
11
12         self.setWindowTitle('center')
13         self.resize(250, 150)
14         self.center()
15
16     def center(self):
17         screen = QtGui.QDesktopWidget().screenGeometry()
18         size = self.geometry()
19         self.move((screen.width()-size.width())/2, (screen.height()-size.height())/2)
20
21
22 app = QtGui.QApplication(sys.argv)
23 c = Center()
24 c.show()
25 sys.exit(app.exec_())

self.resize(250, 150)

将窗口大小调整为宽250px，高150px。

screen = QtGui.QDesktopWidget().screenGeometry()

获得显示器的分辨率。

size = self.geometry()

获得QWidget的大小。

self.move((screen.width()-size.width())/2, (screen.height()-size.height())/2)

将窗口移动到屏幕中央。

glorywine 2008-06-21 23:58 发表评论

PyQt4 - (1) PyQt4简介

glorywine — Sun, 08 Jun 2008 15:06:00 GMT

关于这个教程

这是一个PyQt4的简单教程，目的就是为了让大家对PyQt4有个初步的了解。

关于PyQt
         PyQt是一个GUI库，是将Python和Qt结合在一起的产物。而Qt是目前比较成功和强大的GUI库。你可以通过访问www.riverbankcomputing.co.uk了解更多关于PyQt的消息，目前主要的开发人员是 Phil Thompson.
         PyQt通过一组python模块来实现的，其中包括了超过300个类，尽6000个函数和方法。非常好的是，这个库是平台独立的，可以运行于当前大多操作系统中，包括Unix，Window和Mac。PyQt使用的是双许可证，开发人员可以在GPL和商业许可之间进行选择。过去，GPL仅适用于Unix，从PyQt4开始，GPL对所有的平台开放。
由于PyQt4包含了太多的类，所以开发人员将其分为不同的模块进行管理。

图1：PyQt4模块

         QtCore主要负责一些非GUI的功能，包括时间(time)，文件(files)和文件夹(directories)，各种数据类型(data types)，流(stream)，urls，mime类型，线程(threads)和过程(processes)。QtGui模块负责图像组件和相关的类，包括常见的按钮(buttons)，窗口(windows)，状态栏(status bars)，工具栏(toolbars)，滑动条(sliders)，位图(bitmaps)，颜色(colors)和字体(fonts)等。QtNetwork则负责网络功能，通过该模块，可以完成具有TCP/IP和UDP交互功能的C/S应用，该模块使得网络开发非常的简单便携。QtXml包含了同xml文件交互的能力，模块实现了同SAX和DOM交互的APIs。QtSvg提供了显示SVG文件内容的方法。Scalabe Vector Graphics(SVG)是使用xml文件来描述二维图像的一种语言。QtOpenGL通过使用OpenGL来呈现3D和2D图像，该模块将Qt GUI库和OpenGL库无缝的结合在一起。QtSql提供了访问数据库的方法。

Python

Python是单前非常成功的脚本语言，最开始是由Guido van Rossum进行开发的，在1991年放出了第一个版本。Python的灵感来源于ABC和Haskell。Python是一个高级的，跨平台的解释性语言。很多人喜欢将其称为动态语言。它非常容易学习，最明显的特征是，它不需要分号和括号，而是使用缩进。目前最稳定的版本应该是2.5.2，并且有着来自全球的志愿者进行维护。2007年，Python被评为年度语言。

Python小提示
        如果想使用Python进行GUI开发，目前主要有三个选择，PyGTK，wxPython和PyQt，可以根据开发环境进行选择。还有一个叫做TkInter的，使用的不是非常广泛。

glorywine 2008-06-08 23:06 发表评论