python使用thrift教程的方法示例
python中execute的用法

python中execute的用法在Python中,execute是一个非常重要的方法,它用于执行SQL语句。
在许多数据库操作中,我们都需要使用这个方法来执行SQL语句。
Python的sqlite3模块为我们提供了这个方法,它允许我们直接执行SQL语句,而不需要手动拼接字符串。
一、基本用法在Python中使用execute方法执行SQL语句非常简单。
首先,我们需要创建一个数据库连接对象,然后使用该对象调用execute方法来执行SQL语句。
以下是一个基本的示例:```pythonimportsqlite3#创建数据库连接conn=sqlite3.connect('example.db')#创建一个游标对象cursor=conn.cursor()#执行SQL语句cursor.execute('SELECT*FROMusers')#获取所有结果results=cursor.fetchall()#关闭游标和连接cursor.close()conn.close()```在这个示例中,我们首先创建了一个数据库连接对象,然后创建了一个游标对象。
我们使用游标对象调用execute方法来执行SQL语句。
在这个例子中,我们执行了一个SELECT语句来查询users表中的所有数据。
最后,我们使用fetchall 方法获取所有结果。
二、参数用法execute方法有很多参数,可以根据需要使用不同的参数来执行不同的SQL 语句。
以下是一些常用的参数:1.SQL语句:这是必须的一个参数,它是一个字符串,表示要执行的SQL语句。
2.params:这是一个可选参数,它是一个字典或元组,表示要插入到SQL语句中的参数。
如果提供了这个参数,那么在执行SQL语句时会自动将参数插入到SQL语句中。
例如:```pythoncursor.execute("INSERTINTOusers(name,age)VALUES(?,?)",('Alice',25)) ```在这个例子中,我们使用了两个问号作为占位符来代替要插入的值。
thrift用法

thrift用法
Thrift是一个软件框架,它用于构建跨编程语言的可扩展的服务。
它提供了自动化的RPC(远程过程调用)和序列化,使
不同编程语言的应用程序能够相互通信和交换数据。
Thrift的用法可以分为以下几个方面:
1. 定义数据类型:首先需要使用Thrift的IDL(接口定义语言)来定义数据类型。
IDL是一种类似于结构体定义的语法,用于
描述服务接口和数据类型。
2. 生成代码:使用Thrift提供的编译器,将定义的IDL文件编译成对应的代码,以便在各种编程语言中使用。
Thrift支持多
种编程语言,包括Java、C++、Python等。
3. 实现服务接口:在所选择的编程语言中,根据生成的代码实现服务接口。
这包括定义服务接口的方法,处理客户端的请求,以及返回相应的数据。
4. 启动服务:在服务器上启动Thrift服务,使其能够监听来自
客户端的请求。
可以使用Thrift提供的服务器组件,如TThreadPoolServer、TNonblockingServer等。
5. 客户端调用:在客户端应用程序中使用Thrift客户端库,根
据生成的代码来调用远程服务。
这包括创建一个客户端对象,设置连接参数,调用服务接口的方法,以及处理返回的数据。
通过这些步骤,可以使用Thrift框架来构建跨编程语言的可扩展的服务。
python try 用法

python try 用法Python的try语句允许我们捕获和处理异常。
在本篇文章中,我们将深入了解Python的try语句,了解其用法和遵循的最佳实践。
# 异常处理的背景在编程中,我们经常会遇到代码错误或异常情况。
这些错误或异常可能是由于用户输入错误、网络故障、文件不存在等原因引起的。
为了避免程序崩溃或出现不可预知的行为,我们需要在程序中进行异常处理。
异常处理是一种编程方法,用于捕获和处理发生在程序执行期间的错误或异常情况。
通过合理的异常处理,我们可以避免程序的意外中断,并提供更好的用户体验。
Python中的try语句是一种异常处理机制。
它允许我们在程序中指定可能引发异常的代码块,并在异常发生时执行特定的操作。
# try语句的语法try语句的基本语法如下:pythontry:# 可能引发异常的代码块except [异常类型]:# 异常处理代码块在这个基本语法中,我们通过try关键字定义了一个代码块。
这个代码块是我们希望监视异常的一部分。
当异常发生时,程序会跳过try代码块的剩余部分,转而执行except代码块。
# 捕获特定的异常类型except子句可以用于捕获特定类型的异常。
在except子句中,我们可以指定一个异常类型,以捕获该类型的异常。
例如,我们可以捕获一个特定的异常类型:ZeroDivisionError(当我们除以零时引发)。
pythontry:# 可能引发异常的代码块except ZeroDivisionError:# 处理ZeroDivisionError 异常的代码块这样,我们只捕获并处理ZeroDivisionError异常,而将其他类型的异常传递给上层。
# 捕获多个异常类型除了捕获特定类型的异常,我们还可以使用多个except子句来捕获不同类型的异常。
这样,我们可以根据异常类型执行不同的操作。
以下是使用多个except子句捕获多个异常类型的示例:pythontry:# 可能引发异常的代码块except ZeroDivisionError:# 处理ZeroDivisionError异常的代码块except FileNotFoundError:# 处理FileNotFoundError异常的代码块请注意,except语句的顺序非常重要。
thrift正常的调用过程

自动化thrift的代码示例_server端
thrift的使用过程改进
1 使用thrift工具生成客户端和服务器端代码框架
2
开发人员编写自己的业务代码
3
开发人员用‘thrift生成的代码’+’自己编写 的业务代码’组装成真正的服务
由于thrift设计充分采用了分层思想,这使得我们有可能把上面第二个 环节给省略掉,而采用自动化的方式来完成,这样就比使用thrift生成的静 态代码更能给开发人员带来简便、灵活性。改进后的使用过程如下:
// 第三步: 使用自动Client实例,调用具体的远端服务(用户自己编写的业务代码) CommonArgs tmpCommonArgs = new CommonArgs(); tmpCommonArgs.addOneValue("uid", 10); tmpCommonArgs.addOneValue("test", "test123"); ArrayList tmpList = (ArrayList) client.sendRequest("retrieve", tmpCommonArgs);
tmpAutoThriftGenerator.generateAutoThrift("D:/资料/thrift", "firstTest.thrift"); AutoProcessorGenerator tmpAutoProcessorGenerator = new AutoProcessorGenerator(); TBaseProcessor tmpProcessor = tmpAutoProcessorGenerator.generate("UserStorage", handler, tmpThriftServicesParser);
thrift简单示例(基于C++)

thrift简单⽰例(基于C++)这个thrift的简单⽰例, 来源于官⽹ (/tutorial/cpp), 因为我觉得官⽹的例⼦已经很简单了, 所以没有写新的⽰例, 关于安装的教程, 可以参考https:///albizzia/p/10838646.html, 关于thrift⽂件的语法, 可以参考: https:///albizzia/p/10838646.html.thrift⽂件⾸先给出shared.thrift⽂件的定义:/*** 这个Thrift⽂件包含⼀些共享定义*/namespace cpp sharedstruct SharedStruct {1: i32 key2: string value}service SharedService {SharedStruct getStruct(1: i32 key)}然后给出tutorial.thrift的定义:/*** Thrift引⽤其他thrift⽂件, 这些⽂件可以从当前⽬录中找到, 或者使⽤-I的编译器参数指⽰.* 引⼊的thrift⽂件中的对象, 使⽤被引⼊thrift⽂件的名字作为前缀, 例如shared.SharedStruct.*/include "shared.thrift"namespace cpp tutorial// 定义别名typedef i32 MyInteger/*** 定义常量. 复杂的类型和结构体使⽤JSON表⽰法.*/const i32 INT32CONSTANT = 9853const map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}/*** 枚举是32位数字, 如果没有显式指定值,从1开始.*/enum Operation {ADD = 1,SUBTRACT = 2,MULTIPLY = 3,DIVIDE = 4}/*** 结构体由⼀组成员来组成, ⼀个成员包括数字标识符, 类型, 符号名, 和⼀个可选的默认值.* 成员可以加"optional"修饰符, ⽤来表明如果这个值没有被设置, 那么他们不会被串⾏化到* 结果中. 不过这个在有些语⾔中, 需要显式控制.*/struct Work {1: i32 num1 = 0,2: i32 num2,3: Operation op,4: optional string comment,}// 结构体也可以作为异常exception InvalidOperation {1: i32 whatOp,2: string why}/*** 服务需要⼀个服务名, 加上⼀个可选的继承, 使⽤extends关键字*/service Calculator extends shared.SharedService {/** * ⽅法定义和C语⾔⼀样, 有返回值, 参数或者⼀些它可能抛出的异常, 参数列表和异常列表的 * 写法与结构体中的成员列表定义⼀致. */void ping(),i32 add(1:i32 num1, 2:i32 num2),i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),/** * 这个⽅法有oneway修饰符, 表⽰客户段发送⼀个请求, 然后不会等待回应. Oneway⽅法 * 的返回值必须是void */oneway void zip()}将上述⽂件放置在同⼀个⽂件夹, 然后编译上述的thrift⽂件:$ thrift -r --gen cpp tutorial.thrift⽣成的⽂件会出现在gen-cpp⼦⽂件夹中, 因为编译时使⽤了-r参数, 所以shared.thrift也会被编译.我们可以考虑查看⼀下thrift编译之后⽣成的⽂件, 这⾥, 我们可以考虑先编译shared.thrift, 编译后, 会⽣成7个⽂件, 分别是shared_constants.h, shared_constants.cpp, shared_types.h, shared_types.cpp, SharedService.h, SharedService.cpp, SharedService_server.skeleton.cpp.我们先查看shared_constants.h和shared.constants.cpp, 这两个⽂件的命名是原先的thrift⽂件名, 加上_constants, 换种⽅式说, 就是xxx.thrift会⽣成xxx_constants.h和xxx_constants.cpp. 查看⼀下这两个⽂件中的内容: 其中会有⼀个类叫做xxxConstants, 在这个类中, 会将常量作为公有成员, 然后可以通过⼀个全局变量g_xxx_constants 访问. ⽽xxx_constants.cpp为类函数的定义, 以及全局变量的定义, 应该⽐较容易理解.关于shared_types.h和shared_types.cpp⽂件, 查看shared_types.h中的内容可以看出, shared_types.h中是thrift⽂件中各种类型的定义, 这个根据⽂件名应该可以⼤致猜出. 其中每⼀个结构体对应两部分, 假设这个结构体叫yyy, 那么第⼀个部分是结构体_yyy__isset,这个结构体会为thrift中yyy的每个字段添加⼀个对应的bool值, 名字相同.第⼆部分是结构体yyy. 这个结构体中包括thrift中yyy的每个字段, 加上_yyy__isset对象. 这个对象⽤于yyy读取输⼊给⾃⾝赋值时, 标识某个字段是否被赋值. yyy中的函数主要有如下⼏个: (1) 默认构造函数 (2) 析构函数 (3) 设置成员变量值的函数 (4) ⽐较函数 (5) read函数, ⽤来读取TProtocol对象的内容, 来给⾃⼰赋值 (6) write函数, 将⾃⾝的值写⼊到TProtocol的对象中. 最后还有⼀个swap函数.关于SharedService.h和SharedService.cpp⽂件, 查看SharedService.h中的内容可以看出, 这个⽂件的⽂件名来⾃于thrift中的service SharedService, 假设服务名叫做zzz, 那么就会⽣成对应的zzz.h和zzz.cpp⽂件, ⽤来实现这个服务的接⼝相关的内容. 查看SharedService.h⽂件, 可以看到如下内容:(1) class SharedServiceIf⽤来实现thrift⽂件中SharedService的接⼝,(2) SharedServiceIfFactory⽤来实现SharedServiceIf的⼯⼚接⼝, 构建函数为getHandler, 释放函数为releaseHandler, 其中SharedServiceIf在⼯⼚类中定义别名Handler.(3) SharedServiceIfSingletonFactory是SharedServiceIfFactory的⼀个具体实现, ⽤来实现返回单例的SharedServiceIf对象.(4) SharedServiceNull是SharedServiceIf的不做任何⾏为的实现.(5) _SharedService_getStruct_args__isset是SharedService服务的getStruct函数的参数对应的isset类, ⽤来表⽰这些参数是否存在.(6) SharedService_getStruct_args是SharedService服务的getStruct函数的参数对应的类, ⽤来表⽰⼀个服务的函数的参数, 实现内容和thrift⽂件中的结构体的实现基本⼀致.(7) SharedService_getStruct_pargs⽤处不太清楚.(8) _SharedService_getStruct_result__isset是SharedService服务的getStruct函数的返回值对应的isset函数, ⽤来表⽰返回值是否设置.(9) SharedService_getStruct_result是SharedService服务的getStruct函数的返回值对应的类, ⽤来表⽰⼀个服务的函数的返回值.(10) _SharedService_getStruct_presult__isset和SharedService_getStruct_presult⽤处不太清楚.(11) SharedServiceClient 是thrift中SharedService服务的客户端实现. SharedServiceClient包括以下内容: 1) 构造函数 2) 获取输⼊和输出Protocol的函数 3) 服务中定义的⽅法, 这⾥是getStruct函数, 以及getStruct函数实现的两个函数, void SharedServiceClient::getStruct(SharedStruct& _return, const int32_t key) { send_getStruct(key); recv_getStruct(_return); } (12) SharedServiceProcessor为编译器⾃动⽣成的对象, 位于Protocol层之上, Server层之下, 实现从输⼊protocol中读取数据, 然后交给具体的Handler处理, 然后再将结果写⼊到输出protocol中. 关于这些联系可以参考 https:///albizzia/p/10884907.html. (13) SharedServiceProcessorFactory是SharedServiceProcessor的⼯⼚类. (14) SharedServiceMultiface是SharedServiceIf的具体实现, 实现了类似于chain of responsiblity的效果, 也就是依次调⽤构造函数中传⼊的多个SharedServiceIf对象的对应⽅法. 参考代码:void getStruct(SharedStruct& _return, const int32_t key) {size_t sz = ifaces_.size();size_t i = 0;for (; i < (sz - 1); ++i) {ifaces_[i]->getStruct(_return, key);}ifaces_[i]->getStruct(_return, key);return;}关于SharedService_server.skeleton.cpp⽂件, 假设thrift中定义的服务名叫做zzz, 那么这个⽂件名叫做zzz_server.skeleton.cpp, skeleton的含义是框架, 这个⽂件的作⽤是告诉我们如何写出thrift服务器的代码. 这个⽂件包括两部分:(1) 类SharedServiceHandler, 这个类⽤来实现SharedServiceIf, 假设thrift中的服务名叫做zzz, 那么这个类的名字就相对的叫做zzzHandler. 这个类会给出如果你想要实现SharedServiceIf, 那么你需要实现的具体的函数, 对于这个类来说, 需要实现构造函数和getStruct函数, getStruct函数是服务中定义的函数, 有时候, 你也需要实现析构函数吧.(2) 然后是⼀个main函数, main函数中的内容, 告诉你怎样实现⼀个简单的thrift服务器. 你可以考虑把这个⽂件拷贝⼀份, 然后根据这个拷贝进⾏修改, 实现服务器的功能.如果把shared.thrift和tutorial.thrift⼀起编译, 那么就会出现14个⽂件, 每个thrift⽂件对应7个, ⽂件的布局和作⽤和之前说明的⼀致.服务端代码#include <thrift/concurrency/ThreadManager.h>#include <thrift/concurrency/PlatformThreadFactory.h>#include <thrift/protocol/TBinaryProtocol.h>#include <thrift/server/TSimpleServer.h>#include <thrift/server/TThreadPoolServer.h>#include <thrift/server/TThreadedServer.h>#include <thrift/transport/TServerSocket.h>#include <thrift/transport/TSocket.h>#include <thrift/transport/TTransportUtils.h>#include <thrift/TToString.h>#include <thrift/stdcxx.h>#include <iostream>#include <stdexcept>#include <sstream>#include "../gen-cpp/Calculator.h"using namespace std;using namespace apache::thrift;using namespace apache::thrift::concurrency;using namespace apache::thrift::protocol;using namespace apache::thrift::transport;using namespace apache::thrift::server;using namespace tutorial;using namespace shared;class CalculatorHandler : public CalculatorIf {public:CalculatorHandler() {}void ping() { cout << "ping()" << endl; }int32_t add(const int32_t n1, const int32_t n2) {cout << "add(" << n1 << ", " << n2 << ")" << endl;return n1 + n2;}int32_t calculate(const int32_t logid, const Work& work) {cout << "calculate(" << logid << ", " << work << ")" << endl;int32_t val;switch (work.op) {case Operation::ADD:val = work.num1 + work.num2;break;case Operation::SUBTRACT:val = work.num1 - work.num2;break;case Operation::MULTIPLY:val = work.num1 * work.num2;break;case Operation::DIVIDE:if (work.num2 == 0) {InvalidOperation io;io.whatOp = work.op;io.why = "Cannot divide by 0";throw io;}val = work.num1 / work.num2;break;default:InvalidOperation io;io.whatOp = work.op;io.why = "Invalid Operation";throw io;}SharedStruct ss;ss.key = logid;ss.value = to_string(val);log[logid] = ss;return val;}void getStruct(SharedStruct& ret, const int32_t logid) {cout << "getStruct(" << logid << ")" << endl;ret = log[logid];}void zip() { cout << "zip()" << endl; }protected:map<int32_t, SharedStruct> log;};/*CalculatorIfFactory is code generated.CalculatorCloneFactory is useful for getting access to the server side of thetransport. It is also useful for making per-connection state. Without thisCloneFactory, all connections will end up sharing the same handler instance.*/class CalculatorCloneFactory : virtual public CalculatorIfFactory {public:virtual ~CalculatorCloneFactory() {}virtual CalculatorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo){stdcxx::shared_ptr<TSocket> sock = stdcxx::dynamic_pointer_cast<TSocket>(connInfo.transport);cout << "Incoming connection\n";cout << "\tSocketInfo: " << sock->getSocketInfo() << "\n";cout << "\tPeerHost: " << sock->getPeerHost() << "\n";cout << "\tPeerAddress: " << sock->getPeerAddress() << "\n";cout << "\tPeerPort: " << sock->getPeerPort() << "\n";return new CalculatorHandler;}virtual void releaseHandler( ::shared::SharedServiceIf* handler) {delete handler;}};int main() {TThreadedServer server(stdcxx::make_shared<CalculatorProcessorFactory>(stdcxx::make_shared<CalculatorCloneFactory>()), stdcxx::make_shared<TServerSocket>(9090), //portstdcxx::make_shared<TBufferedTransportFactory>(),stdcxx::make_shared<TBinaryProtocolFactory>());/*// if you don't need per-connection state, do the following insteadTThreadedServer server(stdcxx::make_shared<CalculatorProcessor>(stdcxx::make_shared<CalculatorHandler>()),stdcxx::make_shared<TServerSocket>(9090), //portstdcxx::make_shared<TBufferedTransportFactory>(),stdcxx::make_shared<TBinaryProtocolFactory>());*//*** Here are some alternate server types...// This server only allows one connection at a time, but spawns no threadsTSimpleServer server(stdcxx::make_shared<CalculatorProcessor>(stdcxx::make_shared<CalculatorHandler>()),stdcxx::make_shared<TServerSocket>(9090),stdcxx::make_shared<TBufferedTransportFactory>(),stdcxx::make_shared<TBinaryProtocolFactory>());const int workerCount = 4;stdcxx::shared_ptr<ThreadManager> threadManager =ThreadManager::newSimpleThreadManager(workerCount);threadManager->threadFactory(stdcxx::make_shared<PlatformThreadFactory>());threadManager->start();// This server allows "workerCount" connection at a time, and reuses threadsTThreadPoolServer server(stdcxx::make_shared<CalculatorProcessorFactory>(stdcxx::make_shared<CalculatorCloneFactory>()), stdcxx::make_shared<TServerSocket>(9090),stdcxx::make_shared<TBufferedTransportFactory>(),stdcxx::make_shared<TBinaryProtocolFactory>(),threadManager);*/cout << "Starting the server..." << endl;server.serve();cout << "Done." << endl;return0;}上述代码应该很容易理解, 在这⾥就不解释了.客户端代码#include <iostream>#include <thrift/protocol/TBinaryProtocol.h>#include <thrift/transport/TSocket.h>#include <thrift/transport/TTransportUtils.h>#include <thrift/stdcxx.h>#include "../gen-cpp/Calculator.h"using namespace std;using namespace apache::thrift;using namespace apache::thrift::protocol;using namespace apache::thrift::transport;using namespace tutorial;using namespace shared;int main() {stdcxx::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));stdcxx::shared_ptr<TTransport> transport(new TBufferedTransport(socket));stdcxx::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));CalculatorClient client(protocol);try {transport->open();client.ping();cout << "ping()" << endl;cout << "1 + 1 = " << client.add(1, 1) << endl;Work work;work.op = Operation::DIVIDE;work.num1 = 1;work.num2 = 0;try {client.calculate(1, work);cout << "Whoa? We can divide by zero!" << endl;} catch (InvalidOperation& io) {cout << "InvalidOperation: " << io.why << endl;// or using generated operator<<: cout << io << endl;// or by using std::exception native method what(): cout << io.what() << endl;}work.op = Operation::SUBTRACT;work.num1 = 15;work.num2 = 10;int32_t diff = client.calculate(1, work);cout << "15 - 10 = " << diff << endl;// Note that C++ uses return by reference for complex types to avoid// costly copy constructionSharedStruct ss;client.getStruct(ss, 1);cout << "Received log: " << ss << endl;transport->close();} catch (TException& tx) {cout << "ERROR: " << tx.what() << endl;}}从上⾯的客户端调⽤来看, ⽅法调⽤和本地的类对象的调⽤很相似, thrift的设计算是很巧妙的. ⾥⾯的代码应该不复杂, 所以也不进⾏具体的讲解了.查看⼀下CMakeLists.txt⽂件:cmake_minimum_required(VERSION 2.8)#include_directories(SYSTEM "${Boost_INCLUDE_DIRS}")#Make sure gen-cpp files can be includedinclude_directories("${CMAKE_CURRENT_BINARY_DIR}")include_directories("${CMAKE_CURRENT_BINARY_DIR}/gen-cpp")include_directories("${PROJECT_SOURCE_DIR}/lib/cpp/src")set(tutorialgencpp_SOURCESgen-cpp/Calculator.cppgen-cpp/SharedService.cppgen-cpp/shared_constants.cppgen-cpp/shared_types.cppgen-cpp/tutorial_constants.cppgen-cpp/tutorial_types.cpp)add_library(tutorialgencpp STATIC ${tutorialgencpp_SOURCES})target_link_libraries(tutorialgencpp thrift)add_custom_command(OUTPUT gen-cpp/Calculator.cpp gen-cpp/SharedService.cpp gen-cpp/shared_constants.cpp gen-cpp/shared_types.cpp gen-cpp/tutorial_constants.cpp gen-cpp/tutorial_types.cpp COMMAND ${THRIFT_COMPILER} --gen cpp -r ${PROJECT_SOURCE_DIR}/tutorial/tutorial.thrift)add_executable(TutorialServer CppServer.cpp)target_link_libraries(TutorialServer tutorialgencpp)if (ZLIB_FOUND)target_link_libraries(TutorialServer ${ZLIB_LIBRARIES})endif ()add_executable(TutorialClient CppClient.cpp)target_link_libraries(TutorialClient tutorialgencpp)if (ZLIB_FOUND)target_link_libraries(TutorialClient ${ZLIB_LIBRARIES})endif ()编译运⾏, 我这边启动客户端和服务端的命令分别是:$ LD_LIBRARY_PATH=/usr/local/lib ./TutorialServer$ LD_LIBRARY_PATH=/usr/local/lib ./TutorialClient注: 上述代码可以在thrift源代码中的tutorial/cpp⽂件夹找到.。
result在python中的用法

result在python中的用法在Python中,"result"是一个常用的变量名,它通常用于存储函数或操作的结果。
"result"的具体用法取决于上下文和程序的要求,可以根据需要进行定义和使用。
以下是一些使用"result"变量的示例:
1. 存储函数的返回值:
result = my_function() # 调用函数,并将返回值存储在result变量中
2. 存储计算的结果:
result = 10 + 5 # 将10加5的结果存储在result变量中
3. 存储条件判断的结果:
result = (x > y) # 比较x和y的大小,并将比较结果(True 或False)存储在result变量中
4. 存储列表、字典或其他数据结构的处理结果:
result = my_list[0] # 从列表中获取第一个元素,并将其存储在result变量中
总之,"result"是一个通用的变量名,用于存储各种操作或函数的结果,它的具体含义和用法取决于程序的上下文。
1/ 1。
python 调用HBase 范例

python 调用HBase 范例python 调用HBase 实例新来的一个工程师不懂HBase,java不熟,python还行,我建议他那可以考虑用HBase的thrift调用,完成目前的工作。
首先,安装thrift下载thrift,这里,我用的是thrift-0.7.0-dev.tar.gz 这个版本tar xzf thrift-0.7.0-dev.tar.gzcd thrift-0.7.0-devsudo ./configure --with-cpp=no --with-ruby=nosudo makesudo make install然后,到HBase的源码包里,找到src/main/resources/org/apache/hadoop/hbase/thrift/执行thrift --gen py Hbase.thriftmv gen-py/hbase/ /usr/lib/python2.4/site-packages/ (根据python版本可能有不同)我这里写了些调用的脚本,供大家参考from unittest import TestCase, mainfrom thrift import Thriftfrom thrift.transport import TSocketfrom thrift.transport import TTransportfrom thrift.protocol import TBinaryProtocolfrom hbase import Hbasefrom hbase.ttypes import ColumnDescriptor, Mutation, BatchMutationclass HBaseTester:def __init__(self, netloc, port, table="staftesttable"): self.tableName = tableself.transport = TTransport.TBufferedTransport(TSocket.TSocket(netloc, port))self.protocol =TBinaryProtocol.TBinaryProtocol(self.transport)self.client = Hbase.Client(self.protocol)self.transport.open()tables = self.client.getTableNames()if self.tableName not in tables:self.__createTable()def __del__(self):self.transport.close()def __createTable(self):name = ColumnDescriptor(name='name')foo = ColumnDescriptor(name='foo')self.client.createTable(self.tableName,[name,foo])def put(self,key,name,foo):name = Mutation(column="name:v", value=name)foo = Mutation(column="foo:v",value=foo)self.client.mutateRow(self.tablename,key,[name,foo])def scanner(self,column):scanner =client.scannerOpen(self.tablename,"",[column])r = client.scannerGet(scanner)result= []while r:print r[0]result.append(r[0])r = client.scannerGet(scanner)print "Scanner finished"return resultclass TestHBaseTester(TestCase):def setUp(self):self.writer = HBaseTester("localhost", 9090)def tearDown(self):name = self.writer.tableNameclient = self.writer.clientclient.disableTable(name)client.deleteTable(name)def testCreate(self):tableName = self.writer.tableNameclient = self.writer.clientself.assertTrue(self.writer.tableName inclient.getTableNames())columns =['name:','foo:']for i in client.getColumnDescriptors(tableName): self.assertTrue(i in columns)def testPut(self):self.writer.put("r1","n1","f1")self.writer.put("r2","n2","f2")self.writer.put("r3","n3","")self.writer.scanner("name:")if __name__ == "__main__":main()。
Thrift使用指南董的博客

Thrift使用指南董的博客1. 内容概要本文档比较全面的介绍了thrift(关于thrift框架的介绍,参考我这篇文章:Thrift框架介绍)语法,代码生成结构和应用经验。
本文主要讲述的对象是thrift文件,并未涉及其client和server的编写方法(关于client和server的编写方法,可参考我这篇文章:使用Thrift RPC编写程序)。
本文档大部分内容翻译自文章:“Thrift:The missing Guide“。
2. 语法参考2.1 TypesThrift类型系统包括预定义基本类型,用户自定义结构体,容器类型,异常和服务定义(1) 基本类型bool:布尔类型(true or value),占一个字节byte:有符号字节i16:16位有符号整型i32:32位有符号整型i64:64位有符号整型double:64位浮点数string:未知编码或者二进制的字符串注意,thrift不支持无符号整型,因为很多目标语言不存在无符号整型(如java)。
(2) 容器类型Thrift容器与类型密切相关,它与当前流行编程语言提供的容器类型相对应,采用java泛型风格表示的。
Thrift提供了3种容器类型:List<t1>:一系列t1类型的元素组成的有序表,元素可以重复Set<t1>:一系列t1类型的元素组成的无序表,元素唯一Map<t1,t2>:key/value对(key的类型是t1且key唯一,value类型是t2)。
容器中的元素类型可以是除了service意外的任何合法thrift类型(包括结构体和异常)。
(3) 结构体和异常Thrift结构体在概念上同C语言结构体类型—-一种将相关属性聚集(封装)在一起的方式。
在面向对象语言中,thrift结构体被转换成类。
异常在语法和功能上类似于结构体,只不过异常使用关键字exception而不是struct关键字声明。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
python使用thrift教程的方法示例Python使用Thrift的教程
Apache Thrift是一个开源的跨语言的RPC框架,它允许不同编程语言之间进行无缝通信。
在本教程中,我们将深入了解如何在Python中使用Thrift框架进行开发。
1. 安装Thrift
首先,我们需要安装Thrift框架。
在命令行中运行以下命令来安装Thrift:
```
pip install thrift
```
安装完成后,我们将能够在Python项目中使用Thrift。
2.创建服务定义文件
接下来,我们需要创建一个Thrift服务定义文件,它描述了我们的RPC接口和数据结构。
我们将创建一个简单的示例,其中包含一个用于加法运算的接口。
创建一个名为calculator.thrift的文件,并将以下内容添加到其中:
```
namespace py calculator
service CalculatorService
i32 add(1:i32 num1, 2:i32 num2),
```
在上面的示例中,我们定义了一个名为CalculatorService的服务,
其中包含一个add方法,该方法接受两个整数参数并返回它们的和。
3. 生成Python代码
为了使用Thrift定义的接口,在我们能够在Python中调用它们之前,我们需要生成相应的代码。
在命令行中运行以下命令来生成Python代码:```
thrift --gen py calculator.thrift
```
这将生成一个名为gen-py的目录,其中包含了由Thrift定义生成的Python代码。
我们将在下一步中使用这些代码。
4.创建服务实现
现在,我们将实现我们在接口中定义的方法。
在Python中,我们可
以通过继承Thrift生成的代码中的接口类来实现这些方法。
打开calculator.py文件,并将以下内容添加到文件中:
```python
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from gen_py.calculator import CalculatorService
from gen_py.calculator.ttypes import calculator
class CalculatorHandler:
def add(self, num1, num2):
result = num1 + num2
return result
handler = CalculatorHandler
processor = CalculatorService.Processor(handler)
transport = TSocket.TServerSocket(port=9090)
tfactory = TTransport.TBufferedTransportFactory
pfactory = TBinaryProtocol.TBinaryProtocolFactory
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
server.serve
```
在上面的示例中,我们首先导入了一些必要的库和模块,然后创建了一个名为CalculatorHandler的类。
该类继承自Thrift生成的接口类,并实现了我们在接口中定义的add方法。
接下来,我们创建了一个名为processor的实例,它引用了我们的服务处理程序。
我们还创建了一个传输对象,该对象指定了我们将在哪个端口上运行这个服务。
然后,我们指定了传输和协议工厂,并使用它们创建了一个名为server的SimpleServer实例。
最后,我们调用server的serve方法来启动服务。
5.启动服务
我们已经完成了Thrift服务的实现,现在我们可以在Python中启动该服务了。
在命令行中运行以下命令来启动服务:
```
```
服务将在本地的9090端口上运行。
6. 使用Thrift服务
最后,我们将在另一个Python脚本中示范如何使用刚刚启动的Thrift服务。
创建一个名为client.py的新文件,并将以下内容添加到其中:
```python
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.protocol import TMultiplexedProtocol
from gen_py.calculator import CalculatorService
from gen_py.calculator.ttypes import calculator
transport = TSocket.TSocket('localhost', 9090)
transport = TTransport.TBufferedTransport(transport)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
client = CalculatorService.Client(protocol)
transport.open
result = client.add(10, 20)
print(result)
transport.close
```
在上面的示例中,我们引入了与服务器端相同的库和模块。
我们创建
了一些用于连接到服务器的传输对象,并使用它们创建了一个客户端实例。
然后,我们打开传输连接,并调用客户端实例的add方法来进行远程
过程调用。
最后,我们打印出调用的结果,并关闭传输连接。
7.运行示例
现在我们已经完成了Thrift服务端和客户端的实现,我们可以看看
它们的工作原理。
在一个命令行窗口中运行calculator.py来启动服务器,并在另一个命令行窗口中运行client.py来调用服务。
```
```
```
```
客户端将打印出add方法的结果,即30。
总结:
这个教程向你展示了如何在Python中使用Thrift框架。
我们从创建接口定义文件开始,然后生成了所需的Python代码。
然后,我们实现了在接口中定义的方法,并最终运行了一个完整的Thrift服务端和客户端示例。
Thrift是一个功能强大的跨语言的RPC框架,它允许不同编程语言之间进行无缝通信。
使用Thrift,我们可以轻松地设计和实现分布式系统。
希望这个教程能够帮助你开始使用Thrift进行Python开发。