zkfarmer

Firefox在线听RM.WMA.MP3音乐的解决方法

2009-04-12T03:11:00.000-07:00

新安装的Firefox2.0.0.1不能播放在线音乐，由于FF缺少插件，又不能像Flashplayer一样在线安装，这时如果你的系统中已经装了Realplayer和Mplayer（这两个是Linux平台下应该都要装的媒体播放器），我们就可以手动来解决这个问题。

1，到/usr/lib/mozilla/plugins/ 下这些*.so 的文件都是mplayer for FF的插件, copy它们粘贴它们到你的 firefox/plugins/目录下. 例如/usr/local/firefox2/plugins/
2，同样再到~/realplayer/mozilla/目录下copy nphelix.so到/usr/local/firefox2/plugins/
3，启动FF,在地址栏输入about:plugins, 你会看到已安装的插件’启用’的状态为’是’ ,最后找个在线的音乐试听吧!

http://jatty.szrocket.com/2007/01/02/linux%E4%B8%8Bff%E5%9C%A8%E7%BA%BF%E5%90%ACrmwmamp3/

永中office,linux下使用宋体

2009-04-11T10:47:00.000-07:00

拷贝windows操作系统中Windows目录下的Fonts目录中simsun.ttc到/usr/X11R6/lib/X11/fonts/TrueType/中即可。

python 的函数 vs 方法

2009-03-24T23:23:00.000-07:00

python中函数和参数有什么不同？函数是实现一个操作的程序段，方法是一个对象运行时带有附加参数的函数。

例如： class zkfarmer:
def __init__(self, name):
self.age = age
def printname(self):
return self.name
def printage(age):
return age

执行下列语句
myname = zkfarmer('zkfarmer')
printmyname = myname.printname()

printage(100)

你可能会注意到printname()并没有调用前面的self变量，而事实上如果函数调用中缺少参数，Python会抛出异常－－甚至实际上这个参数也没有什么用处，方法的特别指出就在于把实例对象作为参数的第一个参数传给了函数。调用myname.printname()相当于zkfarmer.printname(myname)。

方法的工作原理是：把实例对象和函数对象封装成一个抽象的对象：方法对象。以一个参数列表调用方法对象时，它就被重新拆封，用实例对象和原始的参数列表构造一个新的参数列表，然后函数对象调用这个新的参数列表。

python 的脚本与模块

2009-03-22T03:21:00.000-07:00

版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明
 http://norno.blogbus.com/logs/2202802.html

python的脚本和模块都是以.py结尾的

这样的话程序是根据什么来判断它是作为脚本还是作为模块？

关键是一个__name__变量(注意前后都是俩个_)

如果它的值是__main__，则是作为脚本运行的

否则是作为模块运行的

if __name__=="__main__":

main()

这里使用if的原因是每个文件都可能是在另外的程序里被用作库模块

而这个特殊的if只有当你直接运行这个文件的时候才为真

如果这个文件是被另外一个程序当作模块引入的

那么__main__的代码就不会被执行

Python import的一个技巧

2009-03-22T03:17:00.000-07:00

版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明
 http://norno.blogbus.com/logs/2166749.html

比如我们在a目录下自己写了一个类在test.py中

其实可以这么操作

import sys

sys.path.append('a目录路径')

import test

这就ok了

其实sys.path就是一个list

比如一般来说

>>> import sys
>>> sys.path
['C:\\Python24\\Lib\\idlelib', 'C:\\WINDOWS\\system32\\python24.zip', 'C:\\Python24', 'C:\\Python24\\DLLs', 'C:\\Python24\\lib', 'C:\\Python24\\lib\\plat-win', 'C:\\Python24\\lib\\lib-tk', 'C:\\Python24\\lib\\site-packages']

python 函数参数的传递

2009-03-22T03:06:00.000-07:00

版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明
 http://norno.blogbus.com/logs/2377663.html

python中函数参数的传递是通过赋值来传递的。函数参数的使用又有俩个方面值得注意：1.函数参数是如何定义的 2.在调用函数的过程中参数是如何被解析

先看第一个问题，在python中函数参数的定义主要有四种方式：
1.F(arg1,arg2,...)
这是最常见的定义方式，一个函数可以定义任意个参数，每个参数间用逗号分割，用这种方式定义的函数在调用的的时候也必须在函数名后的小括号里提供个数相等的值（实际参数），而且顺序必须相同，也就是说在这种调用方式中，形参和实参的个数必须一致，而且必须一一对应，也就是说第一个形参对应这第一个实参。例如：
def a(x,y):
print x,y
调用该函数，a(1,2)则x取1，y取2，形参与实参相对应，如果a(1)或者a(1,2,3)则会报错。

2.F(arg1,arg2=value2,...)
这种方式就是第一种的改进版，提供了默认值
def a(x,y=3):
print x,y
调用该函数，a(1,2)同样还是x取1，y取2，但是如果a(1)，则不会报错了，这个时候x还是1，y则为默认的3。上面这俩种方式，还可以更换参数位置，比如a(y=8,x=3)用这种形式也是可以的。

3.F(*arg1)
上面俩个方式是有多少个形参，就传进去多少个实参，但有时候会不确定有多少个参数，则此时第三种方式就比较有用，它以一个*加上形参名的方式来表示这个函数的实参个数不定，可能为0个也可能为n个。注意一点是，不管有多少个，在函数内部都被存放在以形参名为标识符的tuple中。
>>> def a(*x):
if len(x)==0:
print 'None'
else:
print x
>>> a(1)
(1,) #存放在元组中
>>> a()
None
>>> a(1,2,3)
(1, 2, 3)
>>> a(m=1,y=2,z=3)

Traceback (most recent call last):
File "", line 1, in -toplevel-
a(m=1,y=2,z=3)
TypeError: a() got an unexpected keyword argument 'm'

4.F(**arg1)
形参名前加俩个*表示，参数在函数内部将被存放在以形式名为标识符的dictionary中，这时调用函数的方法则需要采用arg1=value1,arg2=value2这样的形式。
>>> def a(**x):
if len(x)==0:
print 'None'
else:
print x
>>> a()
None
>>> a(x=1,y=2)
{'y': 2, 'x': 1} #存放在字典中
>>> a(1,2) #这种调用则报错

Traceback (most recent call last):
File "", line 1, in -toplevel-
a(1,2)
TypeError: a() takes exactly 0 arguments (2 given)

上面介绍了四种定义方式，接下来看函数参数在调用过程中是怎么被解析的,其实只要记住上面这四种方法优先级依次降低，先1，后2，再3，最后4，也就是先把方式1中的arg解析，然后解析方式2中的arg=value，再解析方式3，即是把多出来的arg这种形式的实参组成个tuple传进去，最后把剩下的key=value这种形式的实参组成一个dictionary传给带俩个星号的形参，也就方式4。
>>> def test(x,y=1,*a,**b):
print x,y,a,b

>>> test(1)
1 1 () {}
>>> test(1,2)
1 2 () {}
>>> test(1,2,3)
1 2 (3,) {}
>>> test(1,2,3,4)
1 2 (3, 4) {}
>>> test(x=1,y=2)
1 2 () {}
>>> test(1,a=2)
1 1 () {'a': 2}
>>> test(1,2,3,a=4)
1 2 (3,) {'a': 4}
>>> test(1,2,3,y=4)

Traceback (most recent call last):
File "", line 1, in -toplevel-
test(1,2,3,y=4)
TypeError: test() got multiple values for keyword argument 'y'

twisted的异步程序

2009-03-20T20:29:00.000-07:00

并发程序介绍

许多计算任务的完成需要相当多的时间，为什么一个任务需要相当多的时间有两个原因：

1.它是高强度的运算（例如因子分解大量的数目），需要一定的CPU时间来计算答案；

2.它不是一个高强度的运算，但是不得不为产生一个结果等待可用的数据。

等待回答

网络程序一个基本的功能是等待数据。想象你有个发送一个概述一些信息的email的函数，这个函数需要连接到一个远程服务器，等待远程服务器的回复，检查远程服务器可否处理该email，等待回复，发送email，等待确认，然后断开连接。

这些步骤中的任一个都可能需要很长一段时间。你的程序可以使用所有可能的模型中最简单的，在这种情况下，它实际上坐下并等待数据被发送和接受，但是这种情况中，它有一些明显和根本的局限性：它不能立刻发送多个邮件；并且事实上当它正发送邮件时，不能做其他的任何事情。

因此，除了最近简单的网络程序外所有的网络程序都避免这种模式。你可以用多中不同模式中的一个，来保持你的程序一直工作，当它正等待一个特定的任务之前发生的一些事情时，任何手边现有的任务都可以继续。

不等待数据

编写网络程序有多种方式。主要的是：

1.用一个分离的操作系统进程处理每个连接，在这种情况中，当一个进程在等待时，操作系统将小心的让其他进程运行；

2.用一个分离的线程处理每个连接，在这种情况中，当一个线程在等待时，线程框架小心的让其他线程运行；

3.在一个线程中使用非阻塞系统调用处理所有的连接。

非阻塞调用

当使用Twisted框架时通常的模块是第三个模块：非阻塞调用。

当在一个线程中处理多个连接时，调度是应用程序的职责，而不是操作系统的职责，并且当每个连接准备读取或写入时通过调用一个注册的函数来实现－－通常知名的是asynchronous，event-driven和callback-based程序。

在这种模型中，早期的email发送函数这样工作：

1.它调用一个连接函数连接远程的服务器；

2.该连接函数立即返回，当该连接被建立时，隐含的通知该email发送程序将被调用；

3.并且一旦连接被建立，连接机制将通知该email发送函数，连接已经就绪。

上面的顺序覆盖我们原始的阻塞序列有什么好处？好处是当该email发送函数直到连接被打开时不能完成它的工作的下一部分时，程序的其余部分可以完成其他任务，例如为其他email连接开始打开序列。因此，整个程序不再等待连接。

回调

典型的异步模块警告一些数据已经就绪就是知名的回调。应用调用一个函数请求一些数据，并且在这个调用中，它也传递一个当数据已经就绪时调用的回调函数作为一个参数。因此该回调函数应该执行该应用需求的数据的任何任务。

在同步程序中，一个函数请求数据，等待数据，然后处理它，在异步程序中，一个函数请求数据，当数据就绪时让库调用回调函数。

延迟

Twisted使用Deferred对象管理回调序列。当异步请求可用时，客户端附加一系列数据给调用的延迟(deferred)（这一些函数就是一系列callbacks，或一个callback chain），在异步请求中如果有一个错误也附加一系列被调用的函数（errbacks和一个errback chain）。当结果可用时，异步库代码调用第一个回调，或者当一个错误发生时调用第一个errback，并且然后Deferred对象管理每个callback或errback函数的结果给链中的下一个函数。

延迟解决的问题

并发问题的第二种－－非高强度计算任务涉及一个可见的延迟－－Deferreds被设计用来解决这个问题。等待硬件访问，数据库访问，和网络访问函数都包含在这种情况中，多用时间延迟改变。

Deferreds被设计用来使Twisted程序等待数据时数据到达前而不用被挂起。它实现这个通过为调用的(程序)库和调用的应用给出一个简单的管理接口。库理解通过调用Deferred.callback

twisted-api-zkfarmer手册

2009-03-20T01:07:00.000-07:00

twisted的api手册，官方只有在线版本的，由于工作需要我做了一份chm格式的手册，和官方的是一致的，给大家放上来。http://www.namipan.com/d/a8ce930ab51a636c93c76e90485c690046c7addf84a94500

11.11 dircache -- 缓存的目录列表

2009-03-11T00:52:00.000-07:00

dircache 模块定义一个使用缓存读取目录列表的函数，并且使用目录的 mtime 是缓存失效，另外，它定义一个通过附加一个斜线注释是否是目录的函数。

dircache 模块定义下列函数：

reset( ): 重置目录缓存。

listdir( path): 返回 path 的目录列表，os.listdir()一样。注意除非 path 改变，再次调用 listdir() 将不在重新读取目录结构。
注意返回的列表应该仅被视为只读。(可能将来的版本可以该变它返回一个元组？)

opendir( path): 同listdir()一样。它的定义是为了向后的兼容性。

annotate( head, list): 假定 list 是相对于 head 的路径的一个列表，并且在合适的位置，每一个指向目录的路径都会被添加一个 "/" 。

>>> import dircache
>>> a = dircache.listdir('/')
>>> a = a[:] # Copy the return value so we can change 'a'
>>> a
['bin', 'boot', 'cdrom', 'dev', 'etc', 'floppy', 'home', 'initrd', 'lib', 'lost+
found', 'mnt', 'proc', 'root', 'sbin', 'tmp', 'usr', 'var', 'vmlinuz']
>>> dircache.annotate('/', a)
>>> a
['bin/', 'boot/', 'cdrom/', 'dev/', 'etc/', 'floppy/', 'home/', 'initrd/', 'lib/
', 'lost+found/', 'mnt/', 'proc/', 'root/', 'sbin/', 'tmp/', 'usr/', 'var/', 'vm
linuz']

由zkfarmer翻译整理。