蜗牛的牛窝 » python

pyqt4开发步骤

蜗牛 — Wed, 10 Feb 2010 02:06:49 +0000

用pyqt4来开发图形界面程序的步骤如下

1：用Qt Designer做好图形界面并保存为x.ui文件
2：用pyqt自带的命令pyuic4 edytor.ui > edytor.py。这样就得到了一个Ui_notepad类(假定窗口名为notepad)
代码大致如下

from PyQt4 import QtCore, QtGui

class Ui_notepad(object):
def setupUi(self, notepad):
notepad.setObjectName("notepad")
notepad.resize(548, 483)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("sakila.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
notepad.setWindowIcon(icon)
self.button_open = QtGui.QPushButton(notepad)
self.button_open.setGeometry(QtCore.QRect(20, 20, 251, 61))
self.button_open.setObjectName("button_open")
self.pushButton_2 = QtGui.QPushButton(notepad)
self.pushButton_2.setGeometry(QtCore.QRect(280, 20, 251, 61))
self.pushButton_2.setObjectName("pushButton_2")
self.editor_window = QtGui.QTextEdit(notepad)
self.editor_window.setGeometry(QtCore.QRect(20, 90, 511, 371))
self.editor_window.setObjectName("editor_window")

self.retranslateUi(notepad)
QtCore.QObject.connect(self.pushButton_2, QtCore.SIGNAL("clicked()"),
notepad.close)
QtCore.QMetaObject.connectSlotsByName(notepad)

def retranslateUi(self, notepad):
notepad.setWindowTitle(QtGui.QApplication.translate("notepad", "记事本", None, QtGui.QApplication.UnicodeUTF8))
self.button_open.setText(QtGui.QApplication.translate("notepad", "打开", None, QtGui.QApplication.UnicodeUTF8))
self.pushButton_2.setText(QtGui.QApplication.translate("notepad", "关闭", None, QtGui.QApplication.UnicodeUTF8))

3：创建一个start.py文件做主文件

import sys
from PyQt4 import QtCore, QtGui
from edytor import Ui_notepad #加载生成的图形界面类

class StartQt4(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_notepad()#实例化这个类
self.ui.setupUi(self)#调用setupUi方法
QtCore.QObject.connect(self.ui.button_open,QtCore.SIGNAL("clicked()"), self.file_dialog)
#绑定信号/槽也就是将电机button_open这个按钮的事件，绑定到file_dialog这个函数上
def file_dialog(self):
self.ui.editor_window.setText('aaaaaaaaaa')

if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = StartQt4()
myapp.show()
sys.exit(app.exec_())

4：发布，新建一个setup.py文件
setup.py如下：
# setup.py

from distutils.core import setup
import py2exe

setup(windows=["loadMain.py"])
5：发布
python setup.py py2exe -p PyQt4，sip
注意：在setup.py中除了导入必需的模块以外，只有一条语句。
distutils.core.setup(windows=['MessageBox.py'])
方括号中就是要编译的脚本名，前边的windows表示将其编译成GUI程序。如果要编译命令行界面的可执行文件，只要将windows改为console

py2exe会在当前目录下生成两个目录 build和dist
build里是一些py2exe运行时产生的中间文件，dist里有最终的可执行文件
library.zip
w9xpopen.exe
python23.dll
hello.exe

不过记得如果要发布到别的机器上时，library.zip、 w9xpopen.exe、python23.dll这几个文件是必须要和hello.exe在一起的。

django学习笔记——进阶——模型

蜗牛 — Sun, 31 Jan 2010 09:41:46 +0000

新建应用程序

在开始之前需要新建一个应用程序。在这之前我们已经创建了 project , 那么 project 和 app 之间到底有什么不同呢？它们的区别就是一个是配置另一个是代码。也就是说一个app是一套Django功能的集合，通常包括模型和视图，按Python的包结构的方式存在。

在“ mysite“ 项目文件下输入下面的命令来创建“ books“ app
python manage.py startapp books
这个命令在mysite目录下新建了一个book的app应用程序

模型

模型创建的流程
1：在settings.py中配置数据库信息
2：在app中models.py文件里定义模型

from django.db import models

class Publisher(models.Model):
name = models.CharField(max_length=30)
address = models.CharField(max_length=50)
city = models.CharField(max_length=60)
state_province = models.CharField(max_length=30)
country = models.CharField(max_length=50)
website = models.URLField()

class Author(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=40)
email = models.EmailField()

class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()

每个模型相当于单个数据库表，每个属性也是这个表中的一个字段

3:模型安装
编辑 settings.py 文件，找到 INSTALLED_APPS 设置,INSTALLED_APPS 告诉 Django 项目哪些 app 处于激活状态.

INSTALLED_APPS = (
# 'django.contrib.auth',
# 'django.contrib.contenttypes',
# 'django.contrib.sessions',
# 'django.contrib.sites',
'mysite.books',
)

首先，用下面的命令对校验模型的有效性：
python manage.py validate
没问题之后运行下面的命令来生成 CREATE TABLE 语句：
python manage.py sqlall books
然后通过下列命令执行SQL
python manage.py syncdb
syncdb 命令是同步你的模型到数据库的一个简单方法。它会根据 INSTALLED_APPS 里设置的app来检查数据库，如果表不存在，它就会创建它。需要注意的是， syncdb 并不能同步模型的修改到数据库。（本章的最后将详细讨论修改数据库的架构）

基本数据访问

from books.models import Publisher
p1 = Publisher(name='Apress', address='2855 Telegraph Avenue',
city='Berkeley', state_province='CA', country='U.S.A.',
website='http://www.apress.com/')
p1.save()
publisher_list = Publisher.objects.all()

首先，导入Publisher模型类，通过这个类我们可以与包含出版社的数据表进行交互。
接着，创建一个“ Publisher“ 类的实例并设置了字段“ name, address“ 等的值。
调用该对象的 save() 方法，将对象保存到数据库中。 Django 会在后台执行一条 INSERT 语句。
最后，使用“ Publisher.objects“ 属性从数据库取出出版商的信息，这个属性可以认为是包含出版商的记录集。这个属性有许多方法，这里先介绍调用“ Publisher.objects.all()“ 方法获取数据库中“ Publisher“ 类的所有对象。这个操作的幕后，Django执行了一条SQL “ SELECT“ 语句。

注意：当你使用Django modle API创建对象时Django并未将对象保存至数据库内，除非你调用“ save()“ 方法
如果需要一步完成对象的创建与存储至数据库，就使用“ objects.create()“ 方法

p1 = Publisher.objects.create(name='Apress',
address='2855 Telegraph Avenue',
city='Berkeley', state_province='CA', country='U.S.A.',
website='http://www.apress.com/')

查询数据
Publisher.objects.all() 查询出表的所有数据
数据过滤
Publisher.objects.filter(name=’Apress’) 查询出name为apress值的记录
Publisher.objects.filter(country=”U.S.A.”, state_province=”CA”)
包含性查找
Publisher.objects.filter(name__contains=”press”) 查找出name中包含press的记录。在 name 和 contains 之间有双下划线。其他的一些查找类型有： icontains (大小写无关的 LIKE ), startswith 和 endswith , 还有 range
获取耽搁数据
Publisher.objects.get(name=”Apress”) 如果结果是多个对象，会导致抛出异常：如果查询没有返回结果也会抛出异常

排序

Publisher.objects.order_by(“state_province”, “address”)
逆向排序
Publisher.objects.order_by(“-name”)
连锁
Publisher.objects.filter(country=”U.S.A.”).order_by(“-name”)

限制返回数量
Publisher.objects.order_by(‘name’)[0] 返回第一个
相当于
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
ORDER BY name
LIMIT 1;
取出特定子集
Publisher.objects.order_by(‘name’)[0:2]
类似于
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
ORDER BY name
LIMIT 0,2;

更新数据
更新单个字段
Publisher.objects.filter(id=52).update(name=’Apress Publishing’)
类似于
UPDATE books_publisher
SET name = ‘Apress Publishing’
WHERE id = 52;

更新多个字段
p = Publisher.objects.get(name=’Apress’)
p.name = ‘Apress Publishing’
p.save()
类似于
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
WHERE name = ‘Apress’;

UPDATE books_publisher SET
name = ‘Apress Publishing’,
address = ‘2855 Telegraph Ave.’,
city = ‘Berkeley’,
state_province = ‘CA’,
country = ‘U.S.A.’,
website = ‘http://www.apress.com’
WHERE id = 52;
在这个例子里我们可以看到Django的save()方法更新了不仅仅是name列的值，还有更新了所有的列。若name以外的列有可能会被其他的进程所改动的情况下，只更改name列显然是更加明智的

删除数据
p = Publisher.objects.get(name=”O’Reilly”)
p.delete()
删除多条记录
Publisher.objects.filter(country=’USA’).delete()

指定模型的缺省排序方式

class Publisher(models.Model):
name = models.CharField(max_length=30)
address = models.CharField(max_length=50)
city = models.CharField(max_length=60)
state_province = models.CharField(max_length=30)
country = models.CharField(max_length=50)
website = models.URLField()

def __unicode__(self):
return self.name

class Meta:
ordering = ['name']

class Meta，内嵌于 Publisher 这个类的定义中（如果 class Publisher 是顶格的，那么 class Meta 在它之下要缩进4个空格－－按 Python 的传统）。你可以在任意一个模型类中使用 Meta 类，来设置一些与特定模型相关的选项

django学习笔记——入门

蜗牛 — Sun, 31 Jan 2010 07:52:58 +0000

本笔记是基于django1.2的,python的版本为2.6.4

开始前的准备

环境的安装我就不记录了，详细的教程看这个 http://djangobook.py3k.cn/2.0/
1：新建一个项目，在你需要新建的目录中执行django-admin.py startproject mysite 命令这样就会在当前目录中生成一个mysite目录
2：运行开发服务器进入mysite目录使用该命令 python manage.py runserver 这将会在端口8000启动一个本地服务器, 并且只能从你的这台电脑连接和访问

视图

新建一个views.py文件，用来做视图。其实用其他文件名也没关系，只不过方便自己以及别人阅读，建议使用views.py,代码如下

from django.http import HttpResponse

def hello(request):
return HttpResponse("Hello world")

HttpResponse的作用是输出html代码到用户浏览器，每个视图函数的第一个参数通常命名为request，这是一个触发这个视图、包含当前Web请求信息的对象，是类django.http.HttpRequest的一个实例。
一个视图就是Python的一个函数。这个函数第一个参数的类型是HttpRequest；它返回一个HttpResponse实例

URL配置

光有上面的视图是没有用的，需要通过URL映射才能起作用

from django.conf.urls.defaults import *
from mysite.views import hello

urlpatterns = patterns('',
('^hello/$', hello),
)

或者

from django.conf.urls.defaults import *
urlpatterns = patterns('',
('^hello/$', "mysite.views.hello"),
)

mysite为项目名 views为视图文件名,如果你用view_2.py做视图文件的话这里就使用mysite.view_2.hello
这里我们只是告诉 Django，所有指向 URL /hello/ 的请求都应由 hello 这个视图函数来处理。
^要求表达式对字符串的头部进行匹配，$符号则要求表达式对字符串的尾部进行匹配

URL正则表达式表

符号	匹配
`.` (dot)	任意单一字符
`\d`	任意一位数字
`[A-Z]`	`A` 到 `Z`中任意一个字符（大写）
`[a-z]`	`a` 到 `z`中任意一个字符（小写）
`[A-Za-z]`	`a` 到 `z`中任意一个字符（不区分大小写）
`+`	匹配一个或更多 (例如, `\d+` 匹配一个或多个数字字符)
`[^/]+`	一个或多个不为‘/’的字符
`*`	零个或一个之前的表达式（例如：`\d?` 匹配零个或一个数字）
`*`	匹配0个或更多 (例如, `\d*` 匹配0个或更多数字字符)
`{1,3}`	介于一个和三个（包含）之前的表达式（例如，`\d{1,3}`匹配一个或两个或三个数字）

django处理URL的流程

1.进来的请求转入/hello/.
2.Django通过在ROOT_URLCONF配置来决定根URLconf.
3.Django在URLconf中的所有URL模式中，查找第一个匹配/hello/的条目。
4.如果找到匹配，将调用相应的视图函数
5.视图函数返回一个HttpResponse
6.Django转换HttpResponse为一个适合的HTTP response，以Web page显示出来

获取URL传递来的参数

1:在URL中配置 [code](r'^time/plus/(\d{1,2})/$', hours_ahead),[/code](\d{1,2})为获取1－99之间的数字
2:视图

def hours_ahead(request, offset):
return HttpResponse(offset)

这里 offset就是获取到的值，当然也可以用其他参数名

新的平台如何抉择？

蜗牛 — Mon, 25 Jan 2010 12:38:50 +0000

策划了好久的web2.0项目，一直没有决定用哪种语言去实现。PHP我很熟悉，python只是略知一二。但是又担心php的性能，所以一直没下定决心。但是考虑到以后这个项目要同时实施在手机上以及在桌面也要有客户端程序，还是决定用python，这样的话WEB 手机桌面都可以用python来实现。用python是定下来了，但是用什么环境呢？用GAE的话，前期都可以不用考虑什么费用了，连空间都不用租了，直接用免费的了，等访问量大了的话就可以向谷歌购买资源来实现，价格也还可以。不过一个很大的问题是，万一谷歌的.com域名又被墙了怎么办？

所以最终还是用python 来实现而不使用GAE。接下来是选择什么WEB框架呢？django还是web.py呢？django适用于敏捷开发，开发难度小耗时短，不过学习成本大一点，而且后期负载大的时候有可能会比较难应付。而web.py简单容易上手，也很方便实施，而且就算负载再大页很容易应付，因为很多东西都是可以控制的。唯一的缺点是开发速度慢一点。综合一下觉得还是用django。一是很多人都推荐用这个，其次是负载大的话也是好事，证明那时候已经有那么多的访问量了，再考虑如何应付也不迟。再者移植到gae上也相对容易一点。

将python程序移植到linux下

蜗牛 — Sat, 09 Jan 2010 13:31:23 +0000

今天将系统上的python程序全部转到linux下，但是却发现出错了。错误提示为:
/usr/bin/python^M: bad interpreter: 没有那个文件或目录

搞了半天，才发现原来是换行的问题，因为在WINDOWS下默认加上了换行符，使用如下命令

$ sed -e 's/.$//' mywin.py > mylinux.py

这个脚本用来替代规则表达式与一行的最末字符匹配，而该字符恰好就是回车。我们用空字符替换它，从而将其从输出中彻底删除。如果使用该脚本并注意到已经删除了输出中每行的最末字符，那么，您就指定了已经是 UNIX格式的文本文件。也就没必要那样做了

python学习笔记(高级篇)

蜗牛 — Mon, 28 Dec 2009 14:40:33 +0000

数据结构

Python中有三种内建的数据结构——列表、元组和字典

列表为可变数据类型，元组为不可变数据类型

列表

shoplist = ['apple', 'mango', 'carrot', 'banana']

shoplist.append('rice') #在列表最后添加一个元素

print shoplist #直接输出这个列表

del shoplist[0] #删除一个元素

print shoplist[1:3]
#注意：输出第二个与第三个元素

元组（元组与列表很像，只不过元组不能修改）

zoo = ('wolf', 'elephant', 'penguin')

new_zoo = ('monkey', 'dolphin', zoo)#相当于一个二元数组

print new_zoo[2][2]

空元组myempty = () 单一元组 singleton = (2 , )

元组与打印

age = 22
name = 'Swaroop'

print '%s is %d years old' % (name, age)

字典

字典就是将键和值联系在一起，并且键必须是唯一的，字典其实就像是PHP中的数组，但是字典中的键/值对是没有顺序的。字典是dict类的实例/对象。

d = {‘key1’ :’ value1’, ‘key2’ : ‘value2’ }

print d[‘key1’]

d[‘key3’]=4 #添加一个新的键值对到字典

del d[‘key1’] #删除一个键值对

for v1, v2 in d.items(): #遍历字典 V1为键 V2为值
print 'Contact %s at %s' % (v1,v2)

序列

列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列

参考！

当你创建一个对象并给它赋一个变量的时候，这个变量仅仅参考那个对象，而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定

#!/usr/bin/python
# Filename: reference.py

print 'Simple Assignment'
shoplist = ['apple', 'mango', 'carrot', 'banana']
mylist = shoplist # mylist is just another name pointing to the same object!

del shoplist[0]

print 'shoplist is', shoplist //这里和下面的输出时一样的
print 'mylist is', mylist //与上面的输出是一样的
# notice that both shoplist and mylist both print the same list without
# the 'apple' confirming that they point to the same object

print 'Copy by making a full slice'
mylist = shoplist[:] # make a copy by doing a full slice
#这就是一个完整的拷贝，不管原来的如何改变，都不会影响到他
del mylist[0] # remove first item

print 'shoplist is', shoplist
print 'mylist is', mylist
# notice that now the two lists are different

你需要记住的只是如果你想要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单对象），那么你必须使用切片操作符来取得拷贝。如果你只是想要使用另一个变量名，两个名称都参考同一个对象，那么如果你不小心的话，可能会引来各种麻烦。

类与对象

注意，即便是整数也被作为对象（属于int类）

对象可以使用普通的属于对象的变量存储数据。属于一个对象或类的变量被称为域，对象也可以使用属于类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。

域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量

self

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self

class Person:
    def __init__(self, name): //构造函数，在类被实例化的时候便会运行
        self.name = name //self.name创建一个类变量
    def sayHi(self):
        print 'Hello, my name is', self.name

p = Person('Swaroop')
p.sayHi()

类变量与对象变量

class Person:
    test=1//类变量   每次被实例化之后他的值会一直保存着，就相当于静态变量
    def __init__(self, name):
        self.name2 = name
        Person.test=Person.test+1
    def sayHi(self):
        print Person.test

p = Person('Swaroop')
p.sayHi()

p2 = Person('Swaroop')
p2.sayHi()

Python中所有的类成员（包括数据成员）都是公共的，所有的方法都是有效的。
只有一个例外：如果你使用的数据成员名称以双下划线前缀比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。
这样就有一个惯例，如果某个变量只想在类或对象中使用，就应该以单下划线前缀。而其他的名称都将作为公共的，可以被其他类/对象使用。记住这只是一个惯例，并不是Python所要求的（与双下划线前缀不同）。
同样，注意__del__方法与 destructor 的概念类似。

继承

class SchoolMember: //基类
    '''Represents any school member.'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print '(Initialized SchoolMember: %s)' % self.name

    def tell(self):
        '''Tell my details.'''
        print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember): //子类继承的方法
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print '(Initialized Teacher: %s)' % self.name

    def tell(self):
        SchoolMember.tell(self)
        print 'Salary: "%d"' % self.salary

class Student(SchoolMember):
    '''Represents a student.'''
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print '(Initialized Student: %s)' % self.name

    def tell(self):
        SchoolMember.tell(<span style="color: #ff0000;">self</span>)
#这里不使用self的话，就不会实例化基类
        print 'Marks: "%d"' % self.marks

t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 22, 75)

print # prints a blank line

members = [t, s]
for member in members:
    member.tell() # works for both Teachers and Students

基本类的__init__方法专门使用self变量调用，这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基本类的constructor，你得亲自专门调用它。

Python总是首先查找本类的方法，在这个例子中就是如此。如果它不能在本类中找到对应的方法，它才开始到基本类中逐个查找。基本类是在类定义的时候，在元组之中指明的。

编码

通过在文件头部加上#-*-coding:utf-8-*- 来定义文件的字符集

python学习笔记(初级篇)

蜗牛 — Mon, 28 Dec 2009 11:54:02 +0000

输入输出：

print 用来输出数据 print(“hello”) 高级用法 print “2+3=”,2+3

raw_input用来获取输入 x=raw_input("请输入一个数字：")

常量

数（4种类型的数）

整数：12345 长整数：大一点的整数浮点数：3.14 复数：2.3-4.6j

字符串

单引号‘abc””def’(用来表示adc””def)

双引号“abc’def”(用来表示abc’def)

三引号"""adbc””efg’"hi””” (利用三引号，你可以指示一个多行的字符串,三引号中间的字符串不需要转义)

转义符（可以用反斜杠转义单引号或者双引号）行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行

自然字符串（自然字符串不会转义）

自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicated by \n"。

Unicode字符串

Python允许你处理Unicode文本——你只需要在字符串前加上前缀u或U。例如，u"This is a Unicode string."。

PHPER注意：单引号和双引号字符串是完全相同的——它们没有在任何方面有不同。

变量

python中变量不需要声明数据类型，而且也无需在变量名前加特殊的标识

运算符

http://paper.sebug.net/python/ch05s02.html

流程控制

if语句：

if a>b":

代码块1

elif a=b:

代码块2

else:

代码块3

注意：Python中没有switch语句

While语句

while a>b:

print a;

else:

print ‘loop is over’

注意：else表示循环执行完毕

for循环

for i in range(1,5):

print i

else:

print ‘loop is over’

注意python中的for循环跟PHP语言中的不一样，python中的for有点像PHP中foreach

break语句：break用来终止循环,并且不会执行else块的语句

continue语句：用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环

函数

自定义函数

def printMax(a=3, b=3):

”’这是一个文档字符串，用来描述函数的作用以及使用方法”’

    if a > b:
        print a, ‘is maximum’
    else:
        print b, ‘is maximum’

return a

printMax(3, 4)

printMax(b=4, a=1) //关键参数，使用这种方法不必担心参数的顺序

变量作用域

在函数中的变量是局部变量

global 声明全局变量

def func():
global x

模块

模块就是一个包含了你所有定义了的变量与函数的文件，为了在其他程序中使用模块，模块必须用.py做扩展名

python标准库模块

import sys 如果你想要直接输入argv变量到你的程序中可以使用from sys import argv，如果要输入所有sys模块使用的名字，那么可以使用from sys import * 语句（每个模块都可以这样输入）

模块的__name__

__name__用PHP的说法就是一个系统常量，表示模块的名称，如果是在本模块里面，那么得到的__name__的值就是‘__main__’ 当被其他文件调用的时候得到的值就是被调用的模块的名称

自定义模块

#!/usr/bin/python
# Filename: mymodule.py

def sayhi():
print ‘Hi, this is mymodule speaking.’

version = ‘0.1′

# End of mymodule.py

下面调用这个模块

import mymodule

mymodule.sayhi()
print ‘Version’, mymodule.version