Python time时间模块用法详解

Python time时间模块需要引用了这个其实也叫函数了我们可以使用time时间模块来进行日期时间的显示了，今天我们一起来看看Python time时间模块用法吧，具体的步骤细节如下文介绍。

看Python time时间模块用法吧，具体的步骤细节如下文介绍。

Python提供time时间模块需要单独引入

#推迟调用线程的运行，secs指秒数。

time.sleep(secs)

时间戳

时间戳都以自从1970年1月1日午夜经过了多长时间来表示,时间间隔是以秒为单位的浮点小数。

import time   # 引入time模块
print U"当前时间戳：",time.time()

输出结果：

当前时间戳： 1471487935.02
当前时间

time.localtime() 函数 用一个元组装起来的9组数字处理时间:

9组数据分别是：tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst

import time
print time.localtime(time.time())
print time.localtime()

输出结果：

time.struct_time(tm_year=2016, tm_mon=8, tm_mday=18, tm_hour=14, tm_min=16, tm_sec=16, tm_wday=3, tm_yday=231, tm_isdst=0)
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=18, tm_hour=14, tm_min=16, tm_sec=16, tm_wday=3, tm_yday=231, tm_isdst=0)

格式化时间

获取可读的时间模式的函数是asctime()

print time.asctime( time.localtime() )

输出结果：

Thu Aug 18 14:04:03 2016

按需求格式化

import time

print time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
print time.strftime("%Y%m%d",time.localtime())
# 将格式字符串转换为时间戳
a = "Thu Aug 18 14:07:27 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

输出结果：

2016-08-18 14:08:13
Thu Aug 18 14:08:13 2016
20160818
1471500447.0

时间，日期，时间戳之间转换

1.将字符串的时间转换为时间戳
    方法:
        a = "2013-10-10 23:40:00"
        将其转换为时间数组
        import time
        timeArray = time.strptime(a, "%Y-%m-%d %H:%M:%S")
    转换为时间戳:
    timeStamp = int(time.mktime(timeArray))
    timeStamp == 1381419600

 

2.字符串格式更改
    如a = "2013-10-10 23:40:00",想改为 a = "2013/10/10 23:40:00"
    方法:先转换为时间数组,然后转换为其他格式
    timeArray = time.strptime(a, "%Y-%m-%d %H:%M:%S")
    otherStyleTime = time.strftime("%Y/%m/%d %H:%M:%S", timeArray)
 
 
3.时间戳转换为指定格式日期:
    方法一:
        利用localtime()转换为时间数组,然后格式化为需要的格式,如
        timeStamp = 1381419600
        timeArray = time.localtime(timeStamp)
        otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
        otherStyletime == "2013-10-10 23:40:00"
 
    方法二:
        import datetime
        timeStamp = 1381419600
        dateArray = datetime.datetime.utcfromtimestamp(timeStamp)
        otherStyleTime = dateArray.strftime("%Y-%m-%d %H:%M:%S")
        otherStyletime == "2013-10-10 23:40:00"
 
4.获取当前时间并转换为指定日期格式
    方法一:
        import time
        获得当前时间时间戳
        now = int(time.time())  ->这是时间戳
        转换为其他日期格式,如:"%Y-%m-%d %H:%M:%S"
        timeArray = time.localtime(timeStamp)
        otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
 
    方法二:
        import datetime
        获得当前时间
        now = datetime.datetime.now()  ->这是时间数组格式
        转换为指定的格式:
        otherStyleTime = now.strftime("%Y-%m-%d %H:%M:%S")
 
5.获得三天前的时间
    方法:
        import time
        import datetime
        先获得时间数组格式的日期
        threeDayAgo = (datetime.datetime.now() - datetime.timedelta(days = 3))
        转换为时间戳:
            timeStamp = int(time.mktime(threeDayAgo.timetuple()))
        转换为其他字符串格式:
            otherStyleTime = threeDayAgo.strftime("%Y-%m-%d %H:%M:%S")
    注:timedelta()的参数有:days,hours,seconds,microseconds
 
6.给定时间戳,计算该时间的几天前时间:
    timeStamp = 1381419600
    先转换为datetime
    import datetime
    import time
    dateArray = datetime.datetime.utcfromtimestamp(timeStamp)
    threeDayAgo = dateArray - datetime.timedelta(days = 3)
    参考5,可以转换为其他的任意格式了

python中时间日期格式化符号：

    %y 两位数的年份表示（00-99）
    %Y 四位数的年份表示（000-9999）
    %m 月份（01-12）
    %d 月内中的一天（0-31）
    %H 24小时制小时数（0-23）
    %I 12小时制小时数（01-12）
    %M 分钟数（00=59）
    %S 秒（00-59）
    %a 本地简化星期名称
    %A 本地完整星期名称
    %b 本地简化的月份名称
    %B 本地完整的月份名称
    %c 本地相应的日期表示和时间表示
    %j 年内的一天（001-366）
    %p 本地A.M.或P.M.的等价符
    %U 一年中的星期数（00-53）星期天为星期的开始
    %w 星期（0-6），星期天为星期的开始
    %W 一年中的星期数（00-53）星期一为星期的开始
    %x 本地相应的日期表示
    %X 本地相应的时间表示
    %Z 当前时区的名称
    %% %号本身

Python自带 Pdb库，使用 Pdb调试 Python程序还是很方便的。但是远程调试、多线程，Pdb是搞不定的，今天我们来看使用Pdb调试Python方法介绍吧。

用Pdb调试有多种方式

使用 Pdb调试 Python的程序的方式主要是下面的三种！下面逐一介绍

命令行加-m参数

命令行启动目标程序，加上-m参数，这样调用 testPdb.py的话断点就是程序执行的第一行之前

本文接下来重点讲到的实例展示就是使用这种方式进行调试的！

python -m pdb testPdb.py
在python交互环境调试

>>> import pdb
>>> import testPdb
>>> pdb.run('testPdb.test()')
代码中插入一段程序

比较常用的，就是在程序中间插入一段程序，相对于在一般 IDE 里面打上断点然后启动 debug，不过这种方式是 hardcode的

if __name__ == "__main__":
  a = 1
  import pdb
  pdb.set_trace()
  b = 2
  c = a + b
  print(c)
然后正常运行脚本： python testPdb.py 到了 pdb.set_trace()那里就会定下来，然后就可以看到调试的提示符 (Pdb)了

针对上面的这段小程序的调试情况如下：

准备测试程序

接下来使用上面介绍的第一种方式来调试 Python程序，以此来介绍 pdb常用的命令，不过在开始之前先要准备好测试的程序代码：

testFun.py

这是一个会被主模块调用的子模块，用于测试使用 Pdb调试的时候，是不是可以断点从主模块跟踪进入子模块（后续有说明）

#!/usr/bin/python
# -*- coding: utf-8 -*-

def add(a, b):
    return a + b
testPdb.py

这是下面被调试的主模块的代码

#!/usr/bin/python
# -*- coding: utf-8 -*-

def sub(a, b):
    return a - b

if __name__ == "__main__":

    print ''
    import testFun
    i = 0
    a = 1
    while(i < 100):
        a = testFun.add(a, 1)
        i = i + 1
    print "累加结果：", a
    print ""

    for letter in 'Pdb':
        print "当前字母：", letter
    print ""

    fruits = ['banana', 'apple', 'mango']
    for fruit in fruits:
        print "当前水果：", fruit
    print ""

    ret = 0
    for num in range(10, 12):
        ret = sub(ret, num)
    print '循环结果：', ret
    print ""

    d = {'abc': 123, 123: "abc"}
    for (k,v) in d.items():
        print "当前键值对：", k, '-', v
    print ""
总结常用的命令

基础命令

h(elp)命令：会打印当前版本 Pdb可用的命令，如果要查询某个命令，可输入 h [command] ，例如 h l 查看 list命令

l(ist)命令：可以列出当前将要运行的代码块

断点管理

b(reak)：设置断点

比如 b 12 就是在当前脚本的第 9行加上断点

比如 b sub 就是在当前脚本的 sub函数定义处加断点

除了可以在当前的脚本中添加断点之外，还可以在当前脚本对其他脚本下断点，以上面用到的代码为例 b testFun.add 就可以实现在 testFun.py脚本中的 add函数处加断点

如果只用 b 就会显示现有的全部断点

condition bpnumber [condition]：设置条件断点，比如 condition 2 a==0 ，就是在第二个断点出加条件 “a==0”

cl(ear)：删除断点，如果后面带有参数，就是清楚指定的断点；如果不带参数就是清除所有的断点

disable/enable：禁用/激活断点

程序逻辑控制

下面展示的几个命令，需要知道对应的脚本的代码和行号，所以这里先截图展示下面测试需要用到的前几行代码

c(ont(inue))，让程序正常运行，直到遇到下一个断点

n(ext)，让程序运行下一行，如果当前语句有一个函数调用，用n是不会进入被调用的函数体中的

下图中展示的，当对脚本断点调试到 testFun.add(a, 1)时，继续执行n，并不会进入 testFun.add(a, 1)的函数内部

s(tep)，跟n相似，但如果当前有一个函数调用，那么 s会进入被调用的函数体中

下图中展示的，当对脚本断点调试到 testFun.add(a, 1)时，继续执行s，会进入 testFun.add(a, 1)对应的函数定义内部，虽然 testFun.add不是本脚本中定义的函数

j(ump)，让程序跳转到指定的行数

假如当前所在行是 10，注意：假如执行了 j 20 之后，那么相当于程序直接跳到 20行，中间的 11~19行其实就直接跳过去根本没有被执行到，所以如果这段代码中有变量的声明或对象的初始化需要在 20行及之后被用到，那么等到用到的时候就可能导致报错！

打印重要信息

a(rgs)，打印当前函数的参数。比如下图就是展示断点进入到 testFun.add内部之后，打印 testFun.add的参数

p，打印某个变量

退出调试

q，直接退出调试；或者使用 Ctrl+D的方式退出

最后说一句

上面展示的使用 Pdb调试的过程其实是很简单的，文章中主要通过截图展示运行的效果。如果单纯的看一遍文章，不出意外，会很没有头绪，甚至感觉截图中的命令、输出乱七八糟，但是如果亲自动手跟着走一遍流程，花不了一小时，但是效果绝对极佳！

下面我们来看一篇关于php socket服务的模型以及实现 多进程IO复用libevent?端口复用技术例子，希望此文章能够对各位有帮助。

端口复用技术，这样就可以很好的解决惊群问题和stream_socket_server性能瓶颈的问题.

<?php
/**
 * 多进程IO复用libevent
 * 同时处理多个连接
 * 端口复用---建议php7
 */
class Xtgxiso_server
{
    public $socket = false;
    public $master = array();
    public $onConnect = null;
    public $onMessage = null;
    public $onClose = null;
    public $process_num = 2;
    private $pids = array();
    public $receive = array();
    private  $host='127.0.0.1';
    private $port = 1215;

    function __construct($host="0.0.0.0",$port=1215){
        //产生子进程分支
        $pid = pcntl_fork();
        if ($pid == -1) {
            die("could not fork"); //pcntl_fork返回-1标明创建子进程失败
        } else if ($pid) {
            exit(); //父进程中pcntl_fork返回创建的子进程进程号
        } else {
            // 子进程pcntl_fork返回的时0
        }
        // 从当前终端分离
        if (posix_setsid() == -1) {
            die("could not detach from terminal");
        }
        umask(0);
        $this->host = $host;
        $this->port = $port;
    }

    private function start_worker_process(){
        $pid = pcntl_fork();
        switch ($pid) {
            case -1:
                echo "fork error : {$i} \r\n";
                exit;
            case 0:
                $context_option['socket']['so_reuseport'] = 1;
                $context = stream_context_create($context_option);
                $this->socket = stream_socket_server("tcp://".$this->host.":".$this->port, $errno, $errstr,STREAM_SERVER_BIND | STREAM_SERVER_LISTEN,$context);
                if (!$this->socket) die($errstr."--".$errno);
                stream_set_blocking($this->socket,0);
                $id = (int)$this->socket;
                $this->master[$id] = $this->socket;
                $base = event_base_new();
                $event = event_new();
                event_set($event, $this->socket, EV_READ | EV_PERSIST, array(__CLASS__, 'ev_accept'), $base);
                event_base_set($event, $base);
                event_add($event);
                echo   posix_getpid()." start run...\n";
                event_base_loop($base);
            default:
                $this->pids[$pid] = $pid;
                break;
        }
    }

    public function run(){

        for($i = 1; $i <= $this->process_num; $i++){
            $this->start_worker_process();
        }

        while(1){
            foreach ($this->pids as $i => $pid) {
                if($pid) {
                    $res = pcntl_waitpid($pid, $status,WNOHANG);

                    if ( $res == -1 || $res > 0 ){
                        $this->start_worker_process();
                        unset($this->pids[$pid]);
                    }
                }
            }
            sleep(1);
        }
    }

    public function ev_accept($socket, $flag, $base){
        $connection = @stream_socket_accept($socket);
        echo posix_getpid()." -- accepted " . stream_socket_get_name($connection,true) . "\n";
        if ( !$connection ){
            return;
        }
        stream_set_blocking($connection, 0);
        $id = (int)$connection;
        if($this->onConnect) {
            call_user_func($this->onConnect, $connection);
        }
        $buffer = event_buffer_new($connection, array(__CLASS__, 'ev_read'), array(__CLASS__, 'ev_write'), array(__CLASS__, 'ev_error'), $id);
        event_buffer_base_set($buffer, $base);
        event_buffer_timeout_set($buffer, 30, 30);
        event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
        event_buffer_priority_set($buffer, 10);
        event_buffer_enable($buffer, EV_READ | EV_PERSIST);
        $this->master[$id] = $connection;
        $this->buffer[$id] = $buffer;
        $this->receive[$id] = '';
    }

    function ev_read($buffer, $id)
    {
        while( 1 ) {
            $read = event_buffer_read($buffer, 3);
            if($read === '' || $read === false)
            {
                break;
            }
            $pos = strpos($read, "\n");
            if($pos === false)
            {
                $this->receive[$id] .= $read;
                //echo "received:".$read.";not all package,continue recdiveing\n";
            }else{
                $this->receive[$id] .= trim(substr ($read,0,$pos+1));
                $read = substr($read,$pos+1);
                if($this->onMessage)
                {
                    call_user_func($this->onMessage,$this->master[$id],$this->receive[$id]);
                }
                switch ( $this->receive[$id] ){
                    case "quit":
                        echo "client close conn\n";
                        if($this->onClose) {
                            call_user_func($this->onClose, $this->master[$id]);
                        }
                        fclose($this->master[$id]);
                        break;
                    default:
                        //echo "all package:\n";
                        //echo $this->receive[$id]."\n";
                        break;
                }
                $this->receive[$id]='';
            }
        }
    }

    function ev_write($buffer, $id)
    {
        echo "$id -- " ."\n";
    }

    function ev_error($buffer, $error, $id)
    {
        echo "ev_error - ".$error."\n";
    }

}
$server =  new Xtgxiso_server();

$server->onConnect = function($conn){
    echo "onConnect -- accepted " . stream_socket_get_name($conn,true) . "\n";
    fwrite($conn,"conn success\n");
};

$server->onMessage = function($conn,$msg){
    echo "onMessage --" . $msg . "\n";
    fwrite($conn,"received ".$msg."\n");
};

$server->onClose = function($conn){
    echo "onClose --" . stream_socket_get_name($conn,true) . "\n";
};

$server->run();
  　经过多次服务模型的演变，基本我们实现了一个高性能的服务模型！

socket异步或同步的教程以前介绍过asp的今天我们看看php中socket编程方式的一篇教程，有兴趣的和小编来看这篇socket服务的模型下的编程方式(同步和异步)例子吧。

    前面我们花了一段时间来搭建高性能的socket服务，可以同时处理大量的连接，但这是在没有具体业务的情况下。

    如果我们启用了一个单进程的server,但里面的一个业务耗时1秒，那么在这1秒内是阻塞的，后续的请求会等待,如果并发三个请求，那么三个请求的执行时间会分别昌1秒,2秒,3秒.提高并发的方法有以下几种:

    1:多启动进程，提高并发数

    2:优化业务，减少耗时间相当于减少阻塞时间，提高并发数

    3:异步编程，避免阻塞，提高并发数

    这里我们重点介绍第三种方法,以访问第三方http为例。

    代码如下：

<?php
//同步读取
function get_data_blocking(){
    $socket = stream_socket_client("tcp://test.raventech.cn:80", $errno, $errstr, 6);
    fwrite($socket, "GET /sleep1.php HTTP/1.0\r\nHost: test.raventech.cn\r\nAccept: */*\r\n\r\n");
    $str = "";
    while (!feof($socket)) {
        $str .= fgets($socket, 1024);
    }
    fclose($socket);
    return $str;
}

//异步读取
function get_data_unblocking(){
    $socket = stream_socket_client("tcp://test.raventech.cn:80", $errno, $errstr, 6);
    stream_set_blocking($socket, 0);
    fwrite($socket, "GET /sleep1.php HTTP/1.0\r\nHost: test.raventech.cn\r\nAccept: */*\r\n\r\n");
    $write  = NULL;
    $except = NULL;
    while( $socket ){
        $read   = array($socket);
        $num_changed_streams = stream_select($read, $write, $except, 0);
        if ( $num_changed_streams > 0 ) {
            foreach($read as $r){
                $str = fread($r,2048);
                fclose($socket);
                $socket = false;
                return $str;
            }
        }
        usleep(100);
    }
}

//真正的异步读取--利用server的IO复用事件来提高并发
class Get_data_event{

    public $onMessage = null;
    private $str='';

    function __construct(&$server){
        $socket = stream_socket_client("tcp://test.xtgxiso.cn:80", $errno, $errstr, 6);
        stream_set_blocking($socket, 0);
        fwrite($socket, "GET /sleep1.php HTTP/1.0\r\nHost: test.xtgxiso.cn\r\nAccept: */*\r\n\r\n");
        $server->add_socket($socket, array($this, 'read'));
    }

    public function read($socket){
        while (1) {
            $buffer = fread($socket, 1024);
            if ($buffer === '' || $buffer === false) {
                break;
            }
            $this->str .= $buffer;
        }
        if( $this->onMessage && $this->str ) {
            call_user_func($this->onMessage, $this->str);
        }
        $this->str = '';
        return false;
    }

}

/**
 * 单进程IO复用select
 */
class Xtgxiso_server
{
    public $socket = false;
    public $master = array();
    public $onConnect = null;
    public $onMessage = null;
    public $other_socket_callback = array();

    function __construct($host="0.0.0.0",$port=1215)
    {
        $this->socket = stream_socket_server("tcp://".$host.":".$port,$errno, $errstr);
        if (!$this->socket) die($errstr."--".$errno);
        stream_set_blocking($this->socket,0);
        $id = (int)$this->socket;
        $this->master[$id] = $this->socket;
    }

    public function add_socket($socket,$callback){
        $id = (int)$socket;
        $this->master[$id] = $socket;
        $this->other_socket_callback[$id] = $callback;
    }

    public function run(){
        $read = $this->master;
        $receive = array();
        echo  "start run...\n";
        while ( 1 ) {
            $read = $this->master;
            //echo  "waiting...\n";
            $mod_fd = @stream_select($read, $_w = NULL, $_e = NULL, 60);
            if ($mod_fd === FALSE) {
                break;
            }
            foreach ( $read as $k => $v ) {
                $id = (int)$v;
                if ( $v === $this->socket ) {
                    //echo "new conn\n";
                    $conn = stream_socket_accept($this->socket);
                    if ($this->onConnect) {
                        call_user_func($this->onConnect, $conn);
                    }
                    $id = (int)$conn;
                    $this->master[$id] = $conn;
                } else if ( @$this->other_socket_callback[$id] ){
                    call_user_func_array($this->other_socket_callback[$id], array($v));
                } else {
                    //echo "read data\n";
                    if ( !isset($receive[$k]) ){
                        $receive[$k]="";
                    }
                    $buffer = fread($v, 1024);
                    //echo $buffer."\n";
                    if ( strlen($buffer) === 0 ) {
                        if ( $this->onClose ){
                            call_user_func($this->onClose,$v);
                        }
                        fclose($v);
                        $id = (int)$v;
                        unset($this->master[$id]);
                    } else if ( $buffer === FALSE ) {
                        if ( $this->onClose ){
                            call_user_func($this->onClose, $this->master[$key_to_del]);
                        }
                        fclose($v);
                        $id = (int)$v;
                        unset($this->master[$id]);
                    } else {
                        $pos = strpos($buffer, "\r\n\r\n");
                        if ( $pos === false) {
                            $receive[$k] .= $buffer;
                            //echo "received:".$buffer.";not all package,continue recdiveing\n";
                        }else{
                            $receive[$k] .= trim(substr ($buffer,0,$pos+4));
                            $buffer = substr($buffer,$pos+4);
                            if($this->onMessage) {
                                call_user_func($this->onMessage,$v,$receive[$k]);
                            }
                            $receive[$k]='';
                        }
                    }
                }
            }
            usleep(10000);
        }
    }
}

$server =  new Xtgxiso_server();

$server->onConnect = function($conn){
    echo "onConnect -- accepted " . stream_socket_get_name($conn,true) . "\n";
};

$server->onMessage = function($conn,$msg) use ( $server ) {
    /*
    $respone ="";//响应内容
    $respone = "HTTP/1.1 200 OK\r\n";
    $respone .= "Server: openresty\r\n";
    $respone .= "Content-Type: text/html; charset=utf-8\r\n";
    $body = time().rand(111111,999999);
    $len = strlen($body);
    $respone .= "Content-Length:$len\r\n";
    $respone .= "Connection: close\r\n";
    $respone .= "\r\n$body\r\n\r\n";
    echo "onMessage --" . $msg . "\n";
    */

    //同步读取
    //$respone = get_data_blocking();
    //fwrite($conn,$respone);

    //异步读取
    //$respone = get_data_unblocking();
    //fwrite($conn,$respone);

    //真正异步
    $data = new Get_data_event($server);
    $data->onMessage = function($str) use($conn){
        fwrite($conn,$str);
    };

};

$server->onClose = function($conn){
    echo "onClose --" . "\n";
};

$server->run();
    第三方服务sleep1.php的代码比较简单

<?php
sleep(1);//模拟耗时
echo "OK";
    通过以上代码示例，我们分别注释运行 同步读取，异步读取,真正异步，来观察server的并发.测试方法可以写个test.html来模拟三个并发.

<script src="http://127.0.0.1:1215/?id=1"></script>
<script src="http://127.0.0.1:1215/?id=2"></script>
<script src="http://127.0.0.1:1215/?id=3"></script>
    通过测试发现，真正异步的是并发的，每个请求耗时1秒，这样我们总算明白什么是真正的非阻塞异步编程了，关键就在共用IO复用.

php语言实现redis的客户端与服务端有一些区别了因为前面介绍过服务端了这里我们来介绍客户端吧，希望文章对各位有帮助。

为了更好的了解redis协议，我们用php来实现一个支持大部份命令的客户端类.

redis的协议可参考这个文章http://redis.cn/topics/protocol.html

代码如下：

<?php
namespace xtgxiso;
class Redis {
    private $redis_socket = false;
    private $cmd = '';
    public function __construct($host='127.0.0.1',$port=6379,$timeout = 3) {
        $this->redis_socket = stream_socket_client("tcp://".$host.":".$port, $errno, $errstr,  $timeout);
        if ( !$this->redis_socket) {
            throw new Exception("{$errno} - {$errstr}");
        }
    }
    public function __destruct() {
        fclose($this->redis_socket);
    }
    public function __call($name, $args) {
        $crlf = "\r\n";
        array_unshift($args,$name);
        $command = '*' . count($args) . $crlf;
        foreach ($args as $arg) {
            $command .= '$' . strlen($arg) . $crlf . $arg . $crlf;
        }
        $fwrite = fwrite($this->redis_socket,$command);
        if ($fwrite === FALSE || $fwrite <= 0) {
            throw new Exception('Failed to write entire command to stream');
        }
        return $this->readResponse();
    }
    private function readResponse() {
        $reply = trim(fgets($this->redis_socket, 1024));
        switch (substr($reply, 0, 1)) {
            case '-':
                throw new Exception(trim(substr($reply, 4)));
                break;
            case '+':
                $response = substr(trim($reply), 1);
                if ($response === 'OK') {
                    $response = TRUE;
                }
                break;
            case '$':
                $response = NULL;
                if ($reply == '$-1') {
                    break;
                }
                $read = 0;
                $size = intval(substr($reply, 1));
                if ($size > 0) {
                    do {
                        $block_size = ($size - $read) > 1024 ? 1024 : ($size - $read);
                        $r = fread($this->redis_socket, $block_size);
                        if ($r === FALSE) {
                            throw new Exception('Failed to read response from stream');
                        } else {
                            $read += strlen($r);
                            $response .= $r;
                        }
                    } while ($read < $size);
                }
                fread($this->redis_socket, 2); /* discard crlf */
                break;
            /* Multi-bulk reply */
            case '*':
                $count = intval(substr($reply, 1));
                if ($count == '-1') {
                    return NULL;
                }
                $response = array();
                for ($i = 0; $i < $count; $i++) {
                    $response[] = $this->readResponse();
                }
                break;
            /* Integer reply */
            case ':':
                $response = intval(substr(trim($reply), 1));
                break;
            default:
                throw new RedisException("Unknown response: {$reply}");
                break;
        }
        return $response;
    }
}
/*
$redis = new Client_test();
var_dump($redis->auth("123456"));
var_dump($redis->set("xtgxiso",'abc'));
var_dump($redis->get("xtgxiso"));
*/
通过实现，我们基本了解redis的协议。