b站晚上少人不宜2024年最新时事新闻
生硬、苦涩，劳神费劲。
Twisted，恰如其名，不折不扣的“弯弯绕“。
啃嚼过程，多半是体力活，不停地点击mouse，从API文档到源代码，跳来跳去，四处寻觅。
真累。手酸、眼花、头晕、心烦，精神健康大致进入“亚”级状态了。呵呵。
最大的痛苦是不知所云。这个framework够诡异的。
但愿逐渐适应它的套路，尽早解开这个“弯弯绕“。
Twisted应用的基本问题，可说是“一个中心，两个基本点”，即：
以“事件”event为中心，以"建立连接"connect和“定义反馈“callback为基本点。
在这些问题上，Twisted有一整套固定的路数，只能照章行事，没有自由发挥的余地。
一、windows下的软件包里没有文档，还需下载unix下的软件包。两个包分别是：
Twisted_NoDocs-2.1.0.win32-py2.4.exe
Twisted-2.1.0.tar
二、文档没有API的，只能上网抓
我用teleport pro抓下它的API的全部在线文档，总共34MB，是软件包的17倍。
三、文档做得粗糙，比java的差远了，只能将就用吧。
四、它有个package叫internet，里面有个管理标准I/O的模块stdio.py，它import了fdesc.py，fdesc.py又import了fcnt1.py。缺了这个文件，无法使用stdio。
这个fcnt1.py是属于python的，但是，windows下的python却没有fcnt1.py，致使有的例程无法运行。
啃嚼快一星期了，不再痛苦难受，逐渐尝出twisted的香甜美味、柔顺可口，开始适应twisted的套路。
twisted的套路，有哪些显著特点呢？接下去说说我品尝出的滋味。
前面把twisted的套路概括成一句话，“一个中心，两个基本点”，现在就从这个“中心”聊起。
Twisted 官方说，“ Twisted is an event-driven networking framework ”。事实的确如此。从其运行机制上看，event 是 Twisted 运转的引擎，是发生各种动作的启动器，是牵一发而动全身的核心部件。从其架构组成上看，它是紧密围绕event设计的；它的具体应用 application，主要是定义、实现各式各样的event，由此完成不同网络协议的连接和输入输出任务，满足用户的实际需求；从其 application的文本形式上，可以直接看到，它的应用程序，基本上由一系列event构成。
由此可见，说它以event为中心，符合实际情况。
Twisted 对event 的管理机制，可划分为后台和前台两种形式。
后台的管理，是Twisted 框架的内在机制，自动运行，对程序员透明无须干预，在程序文本中不见其踪迹。
前台的管理，是Twisted 授权程序员，在程序文本中显式写码来实现。程序员的工作，主要是按照既定的方式，实现 event。我们所关心、所用到的，是这部分东西（API）。
Twisted 众多的 event，分门别类、层次有序。前台管理中，有两个特别的 object，一个叫 reactor ，另一个叫defered。特别之处，在于它俩起着“事件管理器”的作用。下面，说说它俩。
一、统领全局的 reactor
在 Twisted 应用中，reactor 的任务是为程序运行建立必须的全局循环（event loop），所起的作用，相当于 Python 应用中的 MainLoop()。
reactor 的用法很简单，一般只用两个：reactor.run() 启动全局循环，reactor.stop() 停止全局循环（程序终止）。
如果程序中没有调用reactor.stop() 的语句，程序将处于死循环，可以按键 Ctrl-C 强制退出。
下面是一个例子：
from twisted.internet import reactor
import time
def printTime( ):
print "Current time is", time.strftime("%H:%M:%S")
def stopReactor( ):
print "Stopping reactor"
reactor.stop( )
reactor.callLater(1, printTime)
#定时器，1秒钟后调用printTime()
reactor.callLater(2, printTime)
reactor.callLater(3, printTime)
reactor.callLater(5, stopReactor)
#定时器，5秒钟后调用stopReactor()
print "Running the reactor..."
reactor.run( )
print "Reactor stopped."
二、提升效率的 defferred
Twisted 官方称，“Twisted is event-based, asynchronous framework ”。这个“异步”功能的代表就是 defferred。
defferred 的作用类似于“多线程”，负责保障多头连接、多项任务的异步执行。
当然，defferred “异步”功能的实现，与多线程完全不同，具有以下特点：
１、defferred 产生的 event，是函数调用返回的对象；
２、defferred 代表一个连接任务，负责报告任务执行的延迟情况和最终结果；
３、对defferred 的操作，通过预定的“事件响应器”（event handler）进行。
有了defferred，即可对任务的执行进行管理控制。防止程序的运行，由于等待某项任务的完成而陷入阻塞停滞，提高整体运行的效率。
请看下面的例子：
建议只关注黑体字的语句，它们反映了defferred的用法。涉及的两个class，是Twisted建立网络连接的固定套路，后面会专门说它。
# connectiontest.py
from twisted.internet import reactor, defer, protocol
class CallbackAndDisconnectProtocol(protocol.Protocol):
# Twisted建立网络连接的固定套路
def connectionMade(self):
self.factory.deferred.callback("Connected!")
# “事件响应器”handleSuccess对此事件作出处理
self.transport.loseConnection( )
class ConnectionTestFactory(protocol.ClientFactory):
# Twisted建立网络连接的固定套路
protocol = CallbackAndDisconnectProtocol
def __init__(self):
self.deferred = defer.Deferred( )
# 报告发生了延迟事件，防止程序阻塞在这个任务上
def clientConnectionFailed(self, connector, reason):
self.deferred.errback(reason)
# “事件响应器”handleFailure对此事件作出处理
def testConnect(host, port):
testFactory = ConnectionTestFactory( )
reactor.connectTCP(host, port, testFactory)
return testFactory.deferred
# 返回连接任务的deferred
def handleSuccess(result, port):
# deferred“事件响应器”：连接任务完成的处理
print "Connected to port %i" % port
reactor.stop( )
def handleFailure(failure, port):
# deferred“事件响应器”：连接任务失败的处理
print "Error connecting to port %i: %s" % (
port, failure.getErrorMessage( ))
reactor.stop( )
if __name__ == "__main__":
import sys
if not len(sys.argv) == 3:
print "Usage: connectiontest.py host port"
sys.exit(1)
host = sys.argv[1]
port = int(sys.argv[2])
connecting = testConnect(host, port)
# 调用函数，返回deferred
connecting.addCallback(handleSuccess, port)
# 建立deferred“事件响应器”
connecting.addErrback(handleFailure, port)
# 建立deferred“事件响应器”
reactor.run( )
三、创建 client 的套路
第二节说到的两个类，是ＴＣＰ协议客户端的创建套路（方式）。这个套路拆解如下：
１、定义“工厂”和“协议”两个类：
（１）“协议”类是 CallbackAndDisconnectProtocol，“工厂”类是 ConnectionTestFactory
类的名字不重要，但必须正确说明所继承的父类：
class CallbackAndDisconnectProtocol(protocol.Protocol)
class ConnectionTestFactory(protocol.ClientFactory)
（２）“协议”类是“工厂”类实例化的：protocol = CallbackAndDisconnectProtocol；
（３）只在“工厂”类中有 __init__ 函数，并在其中实例化一个deferred 对象：
self.deferred = defer.Deferred( )
（４）在“工厂”类中，重设父类函数 clientConnectionFailed，通过deferred 引发事件，报告连接失败：
self.deferred.errback(reason)
（５）在“协议”类中，重设父类函数 onnectionMade，由对象factory引用“工厂”类中的deferred，经其引发事件，报告连接正常：
self.factory.deferred.callback("Connected!")
并由对象transport引发事件，报告连接断开：
self.transport.loseConnection( )；
上述“对象”，都是从各自父类继承来的。
２、在函数testConnect(host, port)中，
（１）将“工厂”类实例化：testFactory = ConnectionTestFactory( )
（２）由全局循环“主持人”reactor建立以testFactory为“主演”的ＴＣＰ连接：
reactor.connectTCP(host, port, testFactory)
（３）返回deferred对象：return testFactory.deferred
至此，一个以事件驱动为基础、异步执行任务的框架程序搭成了。
上述三节的内容，据 Twisted 官方说，是“学习曲线最陡”的部分（They represent the steepest part of the
Twisted learning curve.）。
我的感受，造成“最陡”的原因，是由于套路新颖独特，初学乍练不易适应。
１、框架对象众多，一时记不牢；
２、对象之间的关系比较复杂，一时理不清；
３、“事件驱动”这种模式，反映在程序文本中，有时见不到明显的函数调用，让人觉得程序的去向不明；
另外，学习方法很重要。如果以学“语言”的习惯来学框架，遇上问题寻根究底，过分追求“水落石出”；或者，依赖教科书、畸重“理论”，忽视 examples 语句、结构和ＡＰＩ文档的分析研究，都不利于翻越这段陡坡。
据我的体验，集中精力地啃嚼主干骨架，不纠緾于细枝末节，这段最陡的上坡路，顶多爬个十天八天的，就能越过去。
Twisted，恰如其名，不折不扣的“弯弯绕“。
啃嚼过程，多半是体力活，不停地点击mouse，从API文档到源代码，跳来跳去，四处寻觅。
真累。手酸、眼花、头晕、心烦，精神健康大致进入“亚”级状态了。呵呵。
最大的痛苦是不知所云。这个framework够诡异的。
但愿逐渐适应它的套路，尽早解开这个“弯弯绕“。
Twisted应用的基本问题，可说是“一个中心，两个基本点”，即：
以“事件”event为中心，以"建立连接"connect和“定义反馈“callback为基本点。
在这些问题上，Twisted有一整套固定的路数，只能照章行事，没有自由发挥的余地。
一、windows下的软件包里没有文档，还需下载unix下的软件包。两个包分别是：
Twisted_NoDocs-2.1.0.win32-py2.4.exe
Twisted-2.1.0.tar
二、文档没有API的，只能上网抓
我用teleport pro抓下它的API的全部在线文档，总共34MB，是软件包的17倍。
三、文档做得粗糙，比java的差远了，只能将就用吧。
四、它有个package叫internet，里面有个管理标准I/O的模块stdio.py，它import了fdesc.py，fdesc.py又import了fcnt1.py。缺了这个文件，无法使用stdio。
这个fcnt1.py是属于python的，但是，windows下的python却没有fcnt1.py，致使有的例程无法运行。
啃嚼快一星期了，不再痛苦难受，逐渐尝出twisted的香甜美味、柔顺可口，开始适应twisted的套路。
twisted的套路，有哪些显著特点呢？接下去说说我品尝出的滋味。
前面把twisted的套路概括成一句话，“一个中心，两个基本点”，现在就从这个“中心”聊起。
Twisted 官方说，“ Twisted is an event-driven networking framework ”。事实的确如此。从其运行机制上看，event 是 Twisted 运转的引擎，是发生各种动作的启动器，是牵一发而动全身的核心部件。从其架构组成上看，它是紧密围绕event设计的；它的具体应用 application，主要是定义、实现各式各样的event，由此完成不同网络协议的连接和输入输出任务，满足用户的实际需求；从其 application的文本形式上，可以直接看到，它的应用程序，基本上由一系列event构成。
由此可见，说它以event为中心，符合实际情况。
Twisted 对event 的管理机制，可划分为后台和前台两种形式。
后台的管理，是Twisted 框架的内在机制，自动运行，对程序员透明无须干预，在程序文本中不见其踪迹。
前台的管理，是Twisted 授权程序员，在程序文本中显式写码来实现。程序员的工作，主要是按照既定的方式，实现 event。我们所关心、所用到的，是这部分东西（API）。
Twisted 众多的 event，分门别类、层次有序。前台管理中，有两个特别的 object，一个叫 reactor ，另一个叫defered。特别之处，在于它俩起着“事件管理器”的作用。下面，说说它俩。
一、统领全局的 reactor
在 Twisted 应用中，reactor 的任务是为程序运行建立必须的全局循环（event loop），所起的作用，相当于 Python 应用中的 MainLoop()。
reactor 的用法很简单，一般只用两个：reactor.run() 启动全局循环，reactor.stop() 停止全局循环（程序终止）。
如果程序中没有调用reactor.stop() 的语句，程序将处于死循环，可以按键 Ctrl-C 强制退出。
下面是一个例子：
from twisted.internet import reactor
import time
def printTime( ):
print "Current time is", time.strftime("%H:%M:%S")
def stopReactor( ):
print "Stopping reactor"
reactor.stop( )
reactor.callLater(1, printTime)
#定时器，1秒钟后调用printTime()
reactor.callLater(2, printTime)
reactor.callLater(3, printTime)
reactor.callLater(5, stopReactor)
#定时器，5秒钟后调用stopReactor()
print "Running the reactor..."
reactor.run( )
print "Reactor stopped."
二、提升效率的 defferred
Twisted 官方称，“Twisted is event-based, asynchronous framework ”。这个“异步”功能的代表就是 defferred。
defferred 的作用类似于“多线程”，负责保障多头连接、多项任务的异步执行。
当然，defferred “异步”功能的实现，与多线程完全不同，具有以下特点：
１、defferred 产生的 event，是函数调用返回的对象；
２、defferred 代表一个连接任务，负责报告任务执行的延迟情况和最终结果；
３、对defferred 的操作，通过预定的“事件响应器”（event handler）进行。
有了defferred，即可对任务的执行进行管理控制。防止程序的运行，由于等待某项任务的完成而陷入阻塞停滞，提高整体运行的效率。
请看下面的例子：
建议只关注黑体字的语句，它们反映了defferred的用法。涉及的两个class，是Twisted建立网络连接的固定套路，后面会专门说它。
# connectiontest.py
from twisted.internet import reactor, defer, protocol
class CallbackAndDisconnectProtocol(protocol.Protocol):
# Twisted建立网络连接的固定套路
def connectionMade(self):
self.factory.deferred.callback("Connected!")
# “事件响应器”handleSuccess对此事件作出处理
self.transport.loseConnection( )
class ConnectionTestFactory(protocol.ClientFactory):
# Twisted建立网络连接的固定套路
protocol = CallbackAndDisconnectProtocol
def __init__(self):
self.deferred = defer.Deferred( )
# 报告发生了延迟事件，防止程序阻塞在这个任务上
def clientConnectionFailed(self, connector, reason):
self.deferred.errback(reason)
# “事件响应器”handleFailure对此事件作出处理
def testConnect(host, port):
testFactory = ConnectionTestFactory( )
reactor.connectTCP(host, port, testFactory)
return testFactory.deferred
# 返回连接任务的deferred
def handleSuccess(result, port):
# deferred“事件响应器”：连接任务完成的处理
print "Connected to port %i" % port
reactor.stop( )
def handleFailure(failure, port):
# deferred“事件响应器”：连接任务失败的处理
print "Error connecting to port %i: %s" % (
port, failure.getErrorMessage( ))
reactor.stop( )
if __name__ == "__main__":
import sys
if not len(sys.argv) == 3:
print "Usage: connectiontest.py host port"
sys.exit(1)
host = sys.argv[1]
port = int(sys.argv[2])
connecting = testConnect(host, port)
# 调用函数，返回deferred
connecting.addCallback(handleSuccess, port)
# 建立deferred“事件响应器”
connecting.addErrback(handleFailure, port)
# 建立deferred“事件响应器”
reactor.run( )
三、创建 client 的套路
第二节说到的两个类，是ＴＣＰ协议客户端的创建套路（方式）。这个套路拆解如下：
１、定义“工厂”和“协议”两个类：
（１）“协议”类是 CallbackAndDisconnectProtocol，“工厂”类是 ConnectionTestFactory
类的名字不重要，但必须正确说明所继承的父类：
class CallbackAndDisconnectProtocol(protocol.Protocol)
class ConnectionTestFactory(protocol.ClientFactory)
（２）“协议”类是“工厂”类实例化的：protocol = CallbackAndDisconnectProtocol；
（３）只在“工厂”类中有 __init__ 函数，并在其中实例化一个deferred 对象：
self.deferred = defer.Deferred( )
（４）在“工厂”类中，重设父类函数 clientConnectionFailed，通过deferred 引发事件，报告连接失败：
self.deferred.errback(reason)
（５）在“协议”类中，重设父类函数 onnectionMade，由对象factory引用“工厂”类中的deferred，经其引发事件，报告连接正常：
self.factory.deferred.callback("Connected!")
并由对象transport引发事件，报告连接断开：
self.transport.loseConnection( )；
上述“对象”，都是从各自父类继承来的。
２、在函数testConnect(host, port)中，
（１）将“工厂”类实例化：testFactory = ConnectionTestFactory( )
（２）由全局循环“主持人”reactor建立以testFactory为“主演”的ＴＣＰ连接：
reactor.connectTCP(host, port, testFactory)
（３）返回deferred对象：return testFactory.deferred
至此，一个以事件驱动为基础、异步执行任务的框架程序搭成了。
上述三节的内容，据 Twisted 官方说，是“学习曲线最陡”的部分（They represent the steepest part of the
Twisted learning curve.）。
我的感受，造成“最陡”的原因，是由于套路新颖独特，初学乍练不易适应。
１、框架对象众多，一时记不牢；
２、对象之间的关系比较复杂，一时理不清；
３、“事件驱动”这种模式，反映在程序文本中，有时见不到明显的函数调用，让人觉得程序的去向不明；
另外，学习方法很重要。如果以学“语言”的习惯来学框架，遇上问题寻根究底，过分追求“水落石出”；或者，依赖教科书、畸重“理论”，忽视 examples 语句、结构和ＡＰＩ文档的分析研究，都不利于翻越这段陡坡。
据我的体验，集中精力地啃嚼主干骨架，不纠緾于细枝末节，这段最陡的上坡路，顶多爬个十天八天的，就能越过去。