#!/usr/bin/python

 

import getopt,sys,time

from thrift.transport.TSocket import TSocket

from thrift.transport.TTransport import TBufferedTransport

from thrift.protocol import TBinaryProtocol

from hbase import Hbase

 

def usage():

        print '''Usage :

        -h: Show help information;

        -l: Show all table in hbase;

        -t {table} Show table descriptors;

        -t {table} -k {key} : show cell;

        -t {table} -k {key} -c {coulmn} : Show the coulmn;

        -t {table} -k {key} -c {coulmn} -v {versions} : Show more version;

    (write by liuhuorong@koudai.com)

        '''

 

class geilihbase:

        def __init__(self):

                self.transport = TBufferedTransport(TSocket("127.0.0.1", "9090"))

                self.transport.open()

                self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport)

                self.client = Hbase.Client(self.protocol)

        def __del__(self):

                self.transport.close()

        def glisttable(self):

                for table in self.client.getTableNames():

                        print table

        def ggetColumnDescriptors(self,table):

                rarr=self.client.getColumnDescriptors(table)

                if rarr:

                        for (k,v) in rarr.items():

                                print "%-20s\t%s" % (k,v)

        def gget(self,table,key,coulmn):

                rarr=self.client.get(table,key,coulmn)

                if rarr:

                        print "%-15s %-20s\t%s" % (rarr[0].timestamp,time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(rarr[0].timestamp/1000)),rarr[0].value)

        def ggetrow(self,table,key):

                rarr=self.client.getRow(table, key)

                if rarr:

                        for (k,v) in rarr[0].columns.items():

                                print "%-20s\t%-15s %-20s\t%s" % (k,v.timestamp,time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(v.timestamp/1000)),v.value)

        def ggetver(self, table, key, coulmn, versions):

                rarr=self.client.getVer(table,key,coulmn, versions);

                if rarr:

                        for row in rarr:

                                print "%-15s %-20s\t%s" % (row.timestamp,time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(row.timestamp/1000)),row.value)

 

def main(argv):

        tablename=""

        key=""

        coulmn=""

        versions=""

        try:

                opts, args = getopt.getopt(argv, "lht:k:c:v:", ["help","list"])

        except getopt.GetoptError:

                usage()

                sys.exit(2)

        for opt, arg in opts:

                if opt in ("-h", "--help"):

                        usage()

                        sys.exit(0)

                elif opt in ("-l", "--list"):

                        ghbase=geilihbase()

                        ghbase.glisttable()

                        sys.exit(0)

                elif opt == '-t':

                        tablename = arg

                elif opt == '-k':

                        key = arg

                elif opt == '-c':

                        coulmn = arg

                elif opt == '-v':

                        versions = int(arg)

        if ( tablename and key and coulmn and versions ):

                ghbase=geilihbase()

                ghbase.ggetver(tablename, key, coulmn, versions)

                sys.exit(0)

        if (tablename and key and coulmn ):

                ghbase=geilihbase()

                ghbase.gget(tablename, key, coulmn)

                sys.exit(0)

        if (tablename and key ):

                ghbase=geilihbase()

                ghbase.ggetrow(tablename, key)

                sys.exit(0)

        if (tablename ):

                ghbase=geilihbase()

                ghbase.ggetColumnDescriptors(tablename)

                sys.exit(0)

        usage()

        sys.exit(1)

 

if __name__ == "__main__":

        main(sys.argv[1:])

前言

日志这东西在语言里算基础组件了吧，可惜Java界第三方框架向来比原生组件好用也是事实，缺点是框架太多混战江湖，今天我们就理一理这些日志框架。Java的日志框架分为门面（Facade），或者叫通用日志接口，还有日志实现。日志接口不用说，就是定下的日志方法规范，需要具体日志组件去实现的（为啥Sun当年没有定义这东西，看看JPA、JDBC、JMS这些规范定义的多好，或者定义了被抛弃了？）。日志实现就是具体的日志组件了，可以实现日志打印到控制台、文件、数据库等等。下面咱们就具体说说这些东西。

Java日志框架分类

日志门面（Facade）

[]Slf4j[/]

全称Simple Logging Facade for JAVA，真正的日志门面，只提供接口方法，当配合特定的日志实现时，需要引入相应的桥接包

[]Common-logging[/]

Apache提供的一个通用的日志接口，common-logging会通过动态查找的机制，在程序运行时自动找出真正使用的日志库，自己也自带一个功能很弱的日志实现。

差别：[list=1][]Common-logging动态查找日志实现（程序运行时找出日志实现），Slf4j则是静态绑定（编译时找到实现），动态绑定因为依赖ClassLoader寻找和载入日志实现，因此类似于OSGI那种使用独立ClassLoader就会造成无法使用的情况。（呵呵，我一个插件用一个日志框架不行啊，土豪多任性，不过说实话，没用过OSGI，这个我还真没有概念）[/][]Slf4j支持参数化的log字符串，避免了之前为了减少字符串拼接的性能损耗而不得不写的if(logger.isDebugEnable())，现在你可以直接写：logger.debug(“current user is: {}”, user)。[/]日志实现

[]Log4j[/]

Log4j可能是Java世界里最出名的日志框架了，支持各种目的地各种级别的日志输出，从我刚接触日志就知道这个框架（呵呵，我一直不知道还有JDK Logging这个东西）。最近（也不近了……）Log4j2发布正式版了，没看到谁用，听说也很不错。

[]LogBack[/]

Log4j作者的又一力作（听说是受不了收费文档搞了个开源的，不需要桥接包完美适配Slf4j），个人感觉迄今为止最棒的日志框架了，一直都在用，配置文件够简洁，性能足够好（估计是看自己的Log4j代码差劲了，更新不能解决问题，直接重构了）。

[]JDK Logging 从JDK1.4开始引入，不得不说，你去Google下这个JDK自带的日志组件，并不如Log4j和LogBack之类好用，木有配置文件，日志级别不好理解，想顺心的用估计还得自己封装下，总之大家已经被Log4j惯坏了，JDK的设计并不能被大家认同，唯一的优点我想就是不用引入新额jar包了。[/]

为什么会有门面

看了以上介绍，如果你不是混迹（深陷）Java多年的老手，估计会蒙圈儿了吧，那你肯定会问，要门面干嘛。有了手机就有手机壳、手机膜，框架也一样，门面的作用更多的还是三个字：解耦合。说白了，加入一个项目用了一个日志框架，想换咋整啊？那就一行一行的找日志改呗，想想都是噩梦。于是，门面出来了，门面说啦， 你用我的格式写日志，把日志想写哪儿写哪儿，例如Slf4j-api加上后，想换日志框架，直接把桥接包一换就行。方便极了。

说实话，现在Slf4j基本可以是Java日志的一个标准了，按照它写基本可以实现所有日志实现通吃，但是就有人不服，还写了门面的门面（没错，这个人就是我）。

门面的门面

如果你看过Netty的源码，推荐你看下io.netty.util.internal.logging这个包里内容，会发现Netty又对日志封装了一层，于是灵感来源于此，我也对各大日志框架和门面做了封装。

Hutool-log模块

无论是Netty的日志模块还是我的Hutool-log模块，思想类似于Common Logging，做动态日志实现查找，然后找到相应的日志实现来写入日志，核心代码如下：

/**

 * 决定日志实现

 * @return 日志实现类

 */

public static Class detectLog(){

    List> logClassList = Arrays.asList(

            Slf4jLog.class,

            Log4jLog.class, 

            Log4j2Log.class, 

            ApacheCommonsLog.class, 

            JdkLog.class

    );

    for (Class clazz : logClassList) {

        try {

            clazz.getConstructor(Class.class).newInstance(LogFactory.class).info("Use Log Framework: [{}]", clazz.getSimpleName());

            return clazz;

        } catch (Error | Exception e) {

            continue;

        }

    }

    return JdkLog.class;

}

详细代码可以看这里

说白了非常简单，按顺序实例化相应的日志实现，如果实例化失败（一般是ClassNotFoundException），说明jar不存在，那实例化下一个，通过不停的尝试，最终如果没有引入日志框架，那使用JDK Logging（这个肯定会有的），当然这种方式也和Common-logging存在类似问题，不过不用到跨ClassLoader还是很好用的。

对于JDK Logging，我也做了一些适配，使之可以与Slf4j的日志级别做对应，这样就将各个日志框架差异化降到最小。另一方面，如果你看过我的这篇日志，那你一定了解了我的类名自动识别功能，这样大家在复制类名的时候，就不用修改日志的那一行代码了，在所有类中，日志的初始化只有这一句：

Log log = LogFactory.get();

是不是简洁简洁又简洁？实现方式也很简单：

/**

 * @return 获得调用者的日志

 */

public static Log get() {

    return getLog(new Exception().getStackTrace()[1].getClassName());

}

通过堆栈引用获得当前类名。
 
作为一个强迫症患者，日志接口我也会定义的非常处女座：

/**

 * 日志统一接口

 * 

 * @author Looly

 *

 */

public interface Log extends TraceLog, DebugLog, InfoLog, WarnLog, ErrorLog

这样就实现了单一使用，各个日志框架灵活引用的作用了。

分享阅读原文：http://www.xiaoleilu.com/some-thing-about-java-log/

Centos安装

1、安装依赖包libdwarf、binutils-devel、lasso、tbb

yum -y install libdwarf-devel libdwarf-tools binutils-devel lasso libdwarf lasso-python libdwarf-tools libdwarf-static tbb

2、创建libdwarf.h软连接

ln -s /usr/include/libdwarf/libdwarf.h /usr/include/libdwarf.h

ln -s /usr/include/libdwarf/dwarf.h /usr/include/dwarf.h

3、获取atosl源码

cd /usr/local/ && git clone https://github.com/facebook/atosl.git

4、安装atosl

cd atosl  #进入源码目录

echo "LDFLAGS += -L/usr/bin" > ./config.mk.local     #添加objdump环境目录

make   #编译安装

5、测试命令

默认安装完成后，命令是在你源码包路径下

Example：/usr/local/atosl是我源码存储目录，那安装完成后命令路径为/usr/local/atosl/atosl

所以需要做个软连接让环境变量中可以查到：

# ln -s /usr/local/atosl/atosl  /usr/bin/atosl

命令结果如下：

Ubuntu安装

1、安装libdwarf-dev、 dwarfdump、binutils-dev 、libiberty-dev软件包

$ sudo apt-get install libdwarf-dev dwarfdump binutils-dev libiberty-dev

2、从github克隆下载atosl源码

$ git clone https://github.com/facebook/atosl.git

3、进入源码目录安装

$ cd atosl



Create a local config config.mk.local which contains a flag with the location of your binutil apps. (in Ubuntu by default that's /usr/bin). If you're not sure, you can find out by executing cat /var/lib/dpkg/info/binutils.list | less and copy the path of the file objdump. E.g. if the entry is /usr/bin/objdump, your path is /usr/bin.



So in the end, your config.mk.local should look like this:



$ echo "LDFLAGS += -L/usr/bin" > ./config.mk.local

$ make

4、测试命令

参考:

https://github.com/facebook/hhvm/issues/536
https://github.com/facebook/hhvm/wiki/Building-and-installing-HHVM-on-CentOS-6.3
http://stackoverflow.com/questions/15070680/ios-symbolication-server-side

正如世界上的语言有多种多样，编程语言同样如此，有些更受欢迎，有些简单易用。随着编 程语言的种类越来越多，它们之间的竞争也日益激烈。而且往往简单的、运行速度快的编程语言并非就是最好的选择，因为不同的程序员对编程语言的选择很有讲究，而且能讲出一大堆道理来解释为什么喜欢某种编程语言 ，不过他们的给出的理由一般都带有太多个人的经历和情感因素。

下面的图表站在客观的立 场，从各个角度对PHP、Ruby、Python三种当前比较流行的语言的优势和劣势进行了对比：Ruby编写的代码精确、强大、表达性好，可用性最高；Python语法简单，最适合初学者学习，也是讨论最为热门的语言；PHP在三者中的流行程度最高；代码效率方面，代码行数PHP表现最好，运行时间上Python最短......,就如下图所示：

更过精彩分析，可以到Youtube观看视频：https://www.youtube.com/watch?v=VBm5m1-Eonw​ 

一、需求及应用场景

考虑到我手上的服务器逐渐的增多，有时候需要大规模的部署同一个文件，例如因为方便使用systemtap这个工具定位问题，需要把手上几百台服务器同时安装kernel-debuginfo这个包，原有的方式采用一个源服务器，采用rsync或者scp之类的文件传输方式只能做到一个点往下分发这个文件，这个时候下发的速度就会比较的慢，基于以上原因，我写了一个基于bt协议传输文件的小工具，实际测试，传输到10个机房，70多台机器传输一个240M的这个内核文件，到所有的机器，源采用限速2m/s的上传速度，测试的结果大概只要140s，就可以全部传输完毕，这个效率是非常之高，如果不限速的情况下速度会更快，下面把这个程序开源出来。

二、代码

#!/usr/bin/env python

import libtorrent as lt

import sys

import os

import time

from optparse import OptionParser

import socket

import struct

import fcntl

def get_interface_ip(ifname):

    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    return socket.inet_ntoa(fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s',

                            ifname[:15]))[20:24])

def ip2long(ip):

    return reduce(lambda a,b:(a<<8)+b,[int(i) for i in ip.split('.')])

def get_wan_ip_address():

    interfaces = set(['eth0', 'eth1', 'eth2', 'eth3', 'em1', 'em2', 'em3', 'em4'])

    ip = ''

    for i in interfaces:

        try:

            ip = get_interface_ip(i)

            if (ip2long(ip) < ip2long('10.0.0.0') or ip2long(ip) > ip2long('10.255.255.255')) \

                and (ip2long(ip) < ip2long('172.16.0.0') or ip2long(ip) > ip2long('172.33.255.255')) \

                and (ip2long(ip) < ip2long('192.168.0.0') or ip2long(ip) > ip2long('192.168.255.255')):

                return ip

        except:

            pass

    return ip

def make_torrent(path, save):

    fs = lt.file_storage()

    lt.add_files(fs, path)

    if fs.num_files() == 0:

        print 'no files added'

        sys.exit(1)

    input = os.path.abspath(path)

    basename = os.path.basename(path)

    t = lt.create_torrent(fs, 0, 4 [i] 1024 [/i] 1024)

    t.add_tracker("http://10.0.1.5:8760/announce")

    t.set_creator('libtorrent %s' % lt.version)

    lt.set_piece_hashes(t, os.path.split(input)[0], lambda x: sys.stderr.write('.'))

    sys.stderr.write('\n')

    save = os.path.dirname(input)

    save = "%s/%s.torrent" % (save, basename)

    f=open(save, "wb")

    f.write(lt.bencode(t.generate()))

    f.close()

    print "the bt torrent file is store at %s" % save

def dl_status(handle):

    while not (handle.is_seed()):

        s = handle.status()

        state_str = ['queued', 'checking', 'downloading metadata', \

                'downloading', 'finished', 'seeding', 'allocating', 'checking fastresume']

        print '\ractive_time: %d, %.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d, seeds: %d) %s' % \

                (s.active_time, s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, \

                s.num_peers, s.num_seeds, state_str[s.state]),

        sys.stdout.flush()

        time.sleep(1)

def seed_status(handle, seedtime=100):

    seedtime = int(seedtime)

    if seedtime < 100:

        seedtime = 100

    while seedtime > 0:

        seedtime -= 1

        s = handle.status()

        state_str = ['queued', 'checking', 'downloading metadata', \

                'downloading', 'finished', 'seeding', 'allocating', 'checking fastresume']

        print '\rseed_time: %d, %.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d, seeds: %d) %s' % \

                (s.active_time, s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, \

                s.num_peers, s.num_seeds, state_str[s.state]),

        sys.stdout.flush()

        time.sleep(1)

def remove_torrents(torrent, session):

    session.remove_torrent(torrent)

def read_alerts(session):

    alert = session.pop_alert()

    while alert:

        #print alert, alert.message()

        alert = session.pop_alert()

def download(torrent, path, upload_rate_limit=0, seedtime=100):

    try:

        session = lt.session()

        session.set_alert_queue_size_limit(1024 * 1024)

        sts = lt.session_settings()

        sts.ssl_listen = False

        sts.user_agent = "Thunder deploy system"

        sts.tracker_completion_timeout = 5

        sts.tracker_receive_timeout = 5

        sts.stop_tracker_timeout = 5

        sts.active_downloads = -1

        sts.active_seeds = -1

        sts.active_limit = -1

        sts.auto_scrape_min_interval = 5

        sts.udp_tracker_token_expiry = 120

        sts.min_announce_interval = 1

        sts.inactivity_timeout = 60

        sts.connection_speed = 10

        sts.allow_multiple_connections_per_ip = True

        sts.max_out_request_queue = 128

        sts.request_queue_size = 3

        sts.use_read_cache = False

        session.set_settings(sts)

        session.set_alert_mask(lt.alert.category_t.tracker_notification | lt.alert.category_t.status_notification)

        session.set_alert_mask(lt.alert.category_t.status_notification)

        ipaddr = get_wan_ip_address()

        #print ipaddr

        if ipaddr == "":

            session.listen_on(6881, 6881)

        else:

            session.listen_on(6881, 6881, ipaddr)

        limit = int(upload_rate_limit)

        if limit>=100:

            session.set_upload_rate_limit(limit*1024)

            session.set_local_upload_rate_limit(limit*1024)

        print session.upload_rate_limit()

        torrent_info = lt.torrent_info(torrent)

        add_params = {

            'save_path': path,

            'storage_mode': lt.storage_mode_t.storage_mode_sparse,

            'paused': False,

            'auto_managed': True,

            'ti': torrent_info,

        }

        handle = session.add_torrent(add_params)

        read_alerts(session)

        st = time.time()

        dl_status(handle)

        et = time.time() - st

        print '\nall file download in %.2f\nstart to seeding\n' % et

        sys.stdout.write('\n')

        handle.super_seeding()

        seed_status(handle, seedtime)

        remove_torrents(handle, session)

        assert len(session.get_torrents()) == 0

    finally:

        print 'download finished'

if __name__ == '__main__':

    usage = "usage: %prog [options] \n \

      %prog -d -f  -s \n \

      or \n \

      %prog -m -p  -s \n"

    parser = OptionParser(usage=usage)

    parser.add_option("-d", "--download", dest="download",

            help="start to download file", action="store_false", default=True)

    parser.add_option("-f", "--file", dest="file",

            help="torrent file")

    parser.add_option("-u", "--upload", dest="upload",

            help="set upload rate limit, default is not limit", default=0)

    parser.add_option("-t", "--time", dest="time",

            help="set seed time, default is 100s", default=100)

    parser.add_option("-p", "--path", dest="path",

            help="to make torrent with this path")

    parser.add_option("-m", "--make", dest="make",

            help="make torrent", action="store_false", default=True)

    parser.add_option("-s", "--save", dest="save",

            help="file save path, default is store to ./", default="./")

    (options, args) = parser.parse_args()

    #download(sys.argv[1])

    if len(sys.argv) != 6 and len(sys.argv) != 4 and len(sys.argv) != 8 and len(sys.argv) != 10:

        parser.print_help()

        sys.exit()

    if options.download == False and options.file !="":

        download(options.file, options.save, options.upload, options.time)

    elif options.make == False and options.path != "":

        make_torrent(options.path, options.save)

三、使用

1、环境准备
需要在所有的os上面安装一个libtorrent的库，下载地址：http://code.google.com/p/libtorrent/downloads/list (国内需使用代理访问)

记得编译的时候带上./configure –enable-python-binding，然后mak，make install，进入binding目录，make，make install就可以运行这个小的工具。当然大规模部署不可能采用每一台都去编译安装的方式，只要把编译出来的libtorrent.so libtorrent-rasterbar.so.7的文件跟bt.py这个文件放到同一个目录，另外写一个shell脚本。

lib=`dirname $0`

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$lib

python bt.py -d -f <种子文件> -s <文件保存路径> -t <做种时间> -u <限制上传速度>

2、使用方法
在源服务器上生成种子文件：

python bt.py -m -p <要发布的文件或者文件夹> -s <种子保存地址>

在源服务器上发布文件：

python bt.py -d -f <种子文件> -s <文件保存路径> -t <做种时间> -u <限制上传速度>

其中做种时间默认设置是100s，上传速度默认不限制，限制速度的单位是kb。
 
只要有一台机器完成了，就自动作为种子，在下载的过程中也会上传，任何一台机器都可以作为源服务器，当然了这里面还有中心的tracker服务器，脚本当中，我搭建了一个tracker源服务器，放到10.0.1.5端口是8760上面，当然大家也可以采用opentracker这个软件自己搭建一个tracker服务器，修改其中的源代码对应部分，另外考虑到发布都是私有文件，代码当作已经禁止了dht，如果还想更安全，就自己搭建一个私有的tracker server，具体搭建方法就使用一下搜索引擎，查找一下搭建的方法！

目前基本做到可以使用，后续考虑更简单一点，采用磁力链接的方式，这样就可以做到不用每台都要拷贝一个种子文件，采用一个单独的命令行就可以发布整个文件。

在使用实用中进行大文件传输时，可以再结合ansible、saltstack等自动化运维工具需要在多台主机之间传大文件时，可以通过该文件加快传输速度，增加网络利用率。

使用input和raw_input都可以读取控制台的输入，但是input和raw_input在处理数字时是有区别的

纯数字输入

当输入为纯数字时

[]input返回的是数值类型，如int,float[/][]raw_inpout返回的是字符串类型，string类型[/]

输入字符串为表达式

input会计算在字符串中的数字表达式，而raw_input不会。
如输入 "57 + 3":
input会得到整数60
raw_input会得到字符串"57 + 3"

输入字符串结果如下：

通过上面的实验我们知道input它会根据用户输入变换相应的类型,而且如果要输入字符和字符串的时候必须要用引号包起来,而raw_input则是不管用户输入什么类型的都会转变成字符型.

python input的实现

看python input的文档，你可以发现input其实是通过raw_input来实现的，原理很简单，就下面一行代码：

def input(prompt):

    return (eval(raw_input(prompt)))

一、域名查询

万网提供了域名查询接口，接口采用HTTP协议：
接口URL：http://panda.www.net.cn/cgi-bin/check.cgi
接口参数：area_domain，接口参数值为标准域名，例：52bong.com
调用举例：

http://panda.www.net.cn/cgi-bin/check.cgi?area_domain=52bong.com

返回：

200

52bong.com

211 : Domain exists

返回结果说明：

200 返回码，200表示返回成功

52bong.com  表示当前查询的域名

211 : Domain exists 返回结果的原始信息，主要有以下几种

 

original=210 : Domain name is available     表示域名可以注册

original=211 : Domain exists    表示域名已经注册

original=212 : Domain name is invalid       表示查询的域名无效

original=213 : Time out 查询超时

Python实现

1.1 查询已经被注册的域名

>>> import urllib2

[quote]>> req=urllib2.urlopen('http://panda.www.net.cn/cgi-bin/check.cgi?area_domain=52bong.com')

>>> print (req.read().decode())

返回结果：不可用，已经被注册

1.2 查询没有被注册的域名

>>> req2=urllib2.urlopen('http://panda.www.net.cn/cgi-bin/check.cgi?area_domain=52bongxxx.com')

>>> print (req2.read().decode())

返回结果：可用，未被注册

1.3 查询不加后缀的域名

>>> req3=urllib2.urlopen('http://panda.www.net.cn/cgi-bin/check.cgi?area_domain=52bong')

>>> print (req3.read().decode())

返回结果：超时

二、whois查询

由于没有找到像域名查询接口那样好的API，这里直接抓取站长之家的whois查询页面(http://whois.chinaz.com/)

>>> whois = urllib2.urlopen('http://whois.chinaz.com/qclouds.com.cn')

>>> print (whois.read().decode())

在返回的结果中有这样一段html代码，这段信息就是查询的whois信息
[/quote]

今天利用python urllib2去站长之家查询域名的whois，然后出现如下错误：

>>> whois = urllib2.urlopen('http://whois.chinaz.com/qclouds.com.cn')

[quote]>> print (whois.read().decode())

Traceback (most recent call last):

  File "", line 1, in 

UnicodeDecodeError: 'ascii' codec can't decode byte 0xe7 in position 273: ordinal not in range(128)

原因分析：

python的str默认是ascii编码，和unicode编码冲突，就会报这个标题错误。

通过搜集网上的资料，自己多次尝试，问题总算是解决了，在代码中加上如下几句即可：

import sys

reload(sys)

sys.setdefaultencoding('utf8')

不知道还有更好的办法吗？
修复后，结果如下：

http://docs.python.org/howto/unicode.html  这个是python的unicode编码API文档，英文好的同学可以看一下，加深理解。
参考资料：https://groups.google.com/forum/#!topic/python-cn/9I73RUUnQPY 

混淆了 python2 里边的 str 和 unicode 数据类型

你需要的是让编码用实际编码而不是 ascii
对需要 str->unicode 的代码，可以在前边写上

import sys

reload(sys)

sys.setdefaultencoding(‘utf8′)

把 str 编码由 ascii 改为 utf8 (或 gb18030)
python3 区分了 unicode str 和 byte arrary，并且默认编码不再是 ascii[/quote]