一、Python基础学习秘籍

技术从何学，一切以基础开始，只有你基础学得越好，后面的学习才会越来越轻松，否则后面高级的学习，你还在回想基础的知识，心猿意马，狗熊掰苞米，得不偿失，所以打好基础是很重要,会让你后面的学习事半功倍，开篇Python大法的基础知识秘籍如下：

二、Python自动化开发秘籍

马步抓稳了，我们可以深入的学习武功心法，要想打通你的Python大法学习筋脉，首先你得有深厚的Python大法的基础的底子，你还得有懒人的思想。其实要想让自己变懒，而且还把钱给挣了，那就是工具自动化，提高你的工作效率，同时降低你的工作重复度，简化你的工作，解放你的生活，周末就可以去撩妹，不用去加班了！下面就把Python大法的自动化秘籍献给大家。

三、Python全栈开发秘籍

全栈是What？Full Stack？全栈可能是每个开发者的最终目标，作为Python大法的爱好者，我想深入学习做为一个Python开发全栈工程师，你怎么着也得会点算法，怎么着也得会点数据结构，你还得会。。。。。。，怎么着，全栈你就得会打得了打BOSS,也得做得了Close Bug，你还得会独立思考，想登峰造极做太极中的张三丰，还得不断学习啊，下面全栈的秘籍也给大家，学到学不到，靠自己。

 
最后我再来张图，娱乐一下大众，学并快乐着！

其实用什么语言不是最重要的，重要的是用的人和他做事的思路和大局观。

俗话说，一图胜千言。图形化的信息可以让人们对数据有更加直观清晰的理解，让信息发布者更加高效地展示自己的核心内容。在前端开发中，如果缺少合适工具，制作数据可视化图表会十分复杂。然而随着数据可视化概念逐年火热，有较多优秀的图表开源库和制作工具脱颖而出。下面，我们就拿其中比较有名的 14个产品进行简要介绍。
 
AnyChart（http://www.anychart.com/ ）
AnyChart 是基于 Flash/JavaScript(HTML5) 的图表解决方案，它可以轻松地跨浏览器、跨平台工作。除了基础的图表功能外，它还有收费的交互式图表和仪表功能。它可以通过 XML 格式获取数据，该方式让开发人员非常灵活地控制图表上的每一个数据点，而当图表数据点数量偏大时，则可以采用 CSV 数据输入，减小数据文件大小和图表加载时间。
 
AmCharts（http://www.amcharts.com/ ）
AmCharts 是一款高级图表库，致力于对 Web 上的数据可视化提供支持。它所支持的图表包括柱状图、条状图、线图、蜡烛图、饼图、雷达、极坐标图、散点图、燃烧图和金字塔图等等。amCharts 库是一款完全独立的类库，在应用中不依赖任何其他第三方类库，就可直接编译运行。除了提供最基本的规范要素外，amCharts 还提供了交互特性。用户在浏览基于 amCharts 制作的图表时，用鼠标 hover 图表内容，可以与其进行交互，使图表展示细节信息，其中呈现信息的容器被叫做 Balloon（气球）。除此之外图表可以动态动画的形式被绘制出来，带来了了非常好的展示效果。
 
Cesium（http://cesiumjs.org/ ）
Cesium 同样专注于地理数据可视化，它是一个 Javascript 库，可以在 Web 浏览器中绘制 3D/2D 地球。无需任何插件即可基于 WebGL 来进行硬件加速。除此之外，它还有跨平台、跨浏览器的特性。Cesium 本身基于 Apache 开源协议，支持商业及非商业项目。
 
Chart.js（https://gionkunz.github.io/chartist-js/ ）
Chartist.js 是一个非常简单而且实用的 JavaScript 图表生成工具，它支持 SVG 格式，图表数据转换灵活，同时也支持多种图表展现形式。在工程中，Chartist.js 的 CSS 和 JavaScript 分离，因此代码比较简洁，在应用时配置流程十分简单。它生成的是响应式图表，可以自动支持不同的浏览器尺寸和分辨率，更多的是，它也支持自定义 SASS 架构。
 
D3.js（http://vis.stanford.edu/papers/d3 ）
2011年，Mike Bostock、Vadim Ogievetsky 和 Jeff Heer 发布了 D3，它是目前 Web 端评价最高的 Javascript 可视化工具库。D3 能够向用户提供大量线性图和条形图之外的复杂图表样式，例如 Voronoi 图、树形图、圆形集群和单词云等等。它的优点是实例丰富，易于实现调试数据同时能够通过扩展实现任何想到的数据可视化效果，缺点是学习门槛比较高。与 jQuery 类似，D3 直接对 DOM 进行操作，这是它与其它可视化工具的主要区别所在：它会设置单独的对象以及功能集，并通过标准 API 进行 DOM 调用。
 
echarts（http://echarts.baidu.com/ ）
一款免费开源的数据可视化产品，给用户提供直观、生动、可交互和可个性化定制的数据可视化图表。Echarts 上手简单。其具有的拖拽重计算、数据视图、值域漫游等特性大大增强了用户体验，帮助用户在对数据挖掘、整合时大幅提高效率。同时，Echarts 提供了丰富的图表类型，除了常见的折柱饼，还支持地图、力导向图、treemap、热力图、树图等等。更惊艳的是，它还支持任意维度的堆积和多图表混合展现。总而言之，这是一款让我们非常惊喜的可视化产品，非常强大，不过他图表不是很美观，对移动端的支持也还有些欠缺，不过这些问题在官方最新发布的3.0 beta中得到了很大改善。
 
Flot（http://www.flotcharts.org/ ）
Flot 是一个纯 Javascript 绘图库，作为 jQuery 的插件使用。它可以较为轻松地跨浏览器工作，甚至包括 IE6。因为 jQuery 的特性，开发者可以全面地控制图表的动画、交互，把数据的呈现过程优化得更加完美。
 
FusionCharts（http://www.fusioncharts.com/ ）
FusionCharts Free 是可跨平台、跨浏览器的 Flash 图表解决方案，它能够被 ASP、.NET、PHP、JSP、ColdFusion、Ruby on Rails、简单 HTML 页面甚至 PPT 调用。在使用过程中，用户原则上并不需要知道任何 Flash 的知识，只需要了解你所用的编程语言，并进行简单的调用即可以实现应用。
 
Google Charts (https://developers.google.com/chart/)
有没有必要过多的介绍这里谷歌图表。 我相信大多数读者都熟悉这个工具，它是功能强大，易于使用，而且免费。
 
HighCharts（ http://www.highcharts.com ）
HighCharts是一个流行的JavaScript图表库。 它提供了一个简单易用的方式，以互动的图表（S）添加到您的网站或Web应用程序。 输出在现代浏览器和VML在Internet Explorer中使用SVG渲染。 图表精美动画眼帘自动，该框架还支持实时数据流。 更重要的是，它是免费下载和使用非商业（以及可授权用于商业用途）。 目前，它支持线，样条曲线，面积，areaspline，柱形图，条形图，饼图，散点图，角规，arearange，areasplinerange，columnrange，气泡，箱形图，误差线，漏斗，瀑布和极地图表类型。
 
Leaflet (http://leafletjs.com/ )
Leaflet是一个开源的JavaScript库，在所有主要的桌面和移动平台的作品。 单张使得它易于使用OpenStreetMap的数据，并在HTML5 / CSS3包装完全集成交互式数据可视化。 这是非常轻（仅为33KB），并有很多的功能作出任何种类的地图。 因此，常常被用于需要展示地理位置的项目。
 
MetricsGraphics（ http://metricsgraphicsjs.org/ ）
MetricsGraphics.js 是一个基于 D3，为可视化和时间序列化的数据而优化的库。它提供了一种便捷的方法，用一致且响应式方式来产生相同类型的图形。它现在支持折线图、散点图、直方图、地毯图和基本的线性回归图。同时，它体积非常小巧，通常可以控制在 60kb 之内。
 
Sigma.js（ http://sigmajs.org ）
Sigma.js是一个JavaScript库，这是专门为使用HTML5 canvas元素绘制图表。 这使得轻松地发布在网页上网络，并允许开发人员在富Web应用程序的网络整合的探索。 西格玛提供了很多不同的设置来轻松地自定义绘图的方式。 此外，公共的API，开发人员可以扩大如何与网络交互的可能性越大（如修改数据，移动相机，刷新渲染，监听事件）。
原文链接：
https://www.reddit.com/r/visualization/comments/3wat64/are_you_ready_for_the_era_of_big_data_14_popular

PHP加载模块，报如下错误：

libmysqlclient.so.16: cannot open shared object file: No such file or directory

这是因为缺少MySQL-shared-compat 的包，系统找不到这个共享文件。
解决如下：
查看有没有装libmysqlclient.so.16：find / -name libmysqlclient.so.16，如果装了就：

ln -s /usr/local/mysql/lib/mysql/libmysqlclient.so.16 /usr/lib/libmysqlclient.so.16

注：/usr/local/mysql/lib/mysql/为libmysqlclient.so.16的路径。在/usr/lib/下建立个软链接。
 
如果没有安装则下载安装：
下载地址：http://rpm.pbone.net/index.php3/stat/3/limit/1/srodzaj/1/dl/40/search/mysql-shared/field/1/field/2
 
方法一：
下载libmysqlclient.so.16，放在/usr/lib下，如果是64位，则放在/usr/lib64下
 
方法二：
采用： MySQL-shared-compat 的rpm包。
运行命令：

wget [url=http://ftp://mirror.switch.ch/pool/4/mirror/mysql/Downloads/MySQL-5.4/MySQL-shared-compat-5.4.3-0.rhel5.x86_64.rpm"]ftp://mirror.switch.ch/pool/4/mirror/mysql/Downloads/MySQL-5.4/MySQL-shared-compat-5.4.3-0.rhel5.x86_64.rpm[/url]

rpm -ivh MySQL-shared-compat-5.4.3-0.rhel5.x86_64.rpm 

提问者的问题​

Python关键字yield的作用是什么？用来干什么的？
比如，我正在试图理解下面的代码:

def node._get_child_candidates(self, distance, min_dist, max_dist):

    if self._leftchild and distance - max_dist < self._median:

        yield self._leftchild

    if self._rightchild and distance + max_dist >= self._median:

        yield self._rightchild

下面的是调用:

result, candidates = list(), [self]

while candidates:

    node = candidates.pop()

    distance = node._get_dist(obj)

    if distance <= max_dist and distance >= min_dist:

        result.extend(node._values)

    candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))

return result

当调用 _get_child_candidates 的时候发生了什么？返回了一个链表？返回了一个元素？被重复调用了么？ 什么时候这个调用结束呢？

回答部分

为了理解什么是 yield,你必须理解什么是生成器。在理解生成器之前，让我们先走近迭代。

可迭代对象

当你建立了一个列表，你可以逐项地读取这个列表，这叫做一个可迭代对象:

>>> mylist = [1, 2, 3]

[quote]>> for i in mylist :

...    print(i)

1

2

3

mylist 是一个可迭代的对象。当你使用一个列表生成式来建立一个列表的时候，就建立了一个可迭代的对象:

>>> mylist = [x*x for x in range(3)]

>>> for i in mylist :

...    print(i)

0

1

4

所有你可以使用 for .. in .. 语法的叫做一个迭代器：链表，字符串，文件……你经常使用它们是因为你可以如你所愿的读取其中的元素，但是你把所有的值都存储到了内存中，如果你有大量数据的话这个方式并不是你想要的。

生成器

生成器是可以迭代的，但是你 只可以读取它一次 ，因为它并不把所有的值放在内存中，它是实时地生成数据:

>>> mygenerator = (x*x for x in range(3))

>>> for i in mygenerator :

...    print(i)

0

1

4

看起来除了把  换成 () 外没什么不同。但是，你不可以再次使用 for i inmygenerator , 因为生成器只能被迭代一次：先计算出0，然后继续计算1，然后计算4，一个跟一个的…

yield关键字

yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器。

>>> def createGenerator() :

...    mylist = range(3)

...    for i in mylist :

...        yield i*i

...

>>> mygenerator = createGenerator() # create a generator

>>> print(mygenerator) # mygenerator is an object!



>>> for i in mygenerator:

...     print(i)

0

1

4

这个例子没什么用途，但是它让你知道，这个函数会返回一大批你只需要读一次的值.
 
为了精通 yield ,你必须要理解：当你调用这个函数的时候，函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象，这有点蹊跷不是吗。
 
那么，函数内的代码什么时候执行呢？当你使用for进行迭代的时候.
 
现在到了关键点了！
 
第一次迭代中你的函数会执行，从开始到达 yield 关键字，然后返回 yield 后的值作为第一次迭代的返回值. 然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的。
 
如果生成器内部没有定义 yield 关键字，那么这个生成器被认为成空的。这种情况可能因为是循环进行没了，或者是没有满足 if/else 条件。

回到你的代码

(译者注:这是回答者对问题的具体解释)
生成器:

# Here you create the method of the node object that will return the generator

def node._get_child_candidates(self, distance, min_dist, max_dist):[/quote]



  # Here is the code that will be called each time you use the generator object :



  # If there is still a child of the node object on its left

  # AND if distance is ok, return the next child

  if self._leftchild and distance - max_dist < self._median:

            yield self._leftchild



  # If there is still a child of the node object on its right

  # AND if distance is ok, return the next child

  if self._rightchild and distance + max_dist >= self._median:

                yield self._rightchild



  # If the function arrives here, the generator will be considered empty

  # there is no more than two values : the left and the right children

调用者:

# Create an empty list and a list with the current object reference

result, candidates = list(), [self]



# Loop on candidates (they contain only one element at the beginning)

while candidates:



    # Get the last candidate and remove it from the list

    node = candidates.pop()



    # Get the distance between obj and the candidate

    distance = node._get_dist(obj)



    # If distance is ok, then you can fill the result

    if distance <= max_dist and distance >= min_dist:

        result.extend(node._values)



    # Add the children of the candidate in the candidates list

    # so the loop will keep running until it will have looked

    # at all the children of the children of the children, etc. of the candidate

    candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))



return result

这个代码包含了几个小部分：

[]我们对一个链表进行迭代，但是迭代中链表还在不断的扩展。它是一个迭代这些嵌套的数据的简洁方式，即使这样有点危险，因为可能导致无限迭代。candidates.extend(node._get_child_candidates(distance, min_dist,max_dist)) 穷尽了生成器的所有值，但 while 不断地在产生新的生成器，它们会产生和上一次不一样的值，既然没有作用到同一个节点上.[/][]extend() 是一个迭代器方法，作用于迭代器，并把参数追加到迭代器的后面。[/]

通常我们传给它一个链表参数:

>>> a = [1, 2][quote]>> b = [3, 4]>>> a.extend(b)>>> print(a)[1, 2, 3, 4]

但是在你的代码中的是一个生成器，这是不错的，因为：

[]你不必读两次所有的值[/][]你可以有很多子对象，但不必叫他们都存储在内存里面。[/]

并且这很奏效，因为Python不关心一个方法的参数是不是个链表。Python只希望它是个可以迭代的，所以这个参数可以是链表，元组，字符串，生成器... 这叫做 ducktyping,这也是为何Python如此棒的原因之一，但这已经是另外一个问题了...
 
你可以在这里停下，来看看生成器的一些高级用法

控制生成器的穷尽

>>> class Bank(): # let's create a bank, building ATMs

...    crisis = False

...    def create_atm(self) :

...        while not self.crisis :

...            yield "$100"

>>> hsbc = Bank() # when everything's ok the ATM gives you as much as you want

>>> corner_street_atm = hsbc.create_atm()

>>> print(corner_street_atm.next())

$100

>>> print(corner_street_atm.next())

$100

>>> print([corner_street_atm.next() for cash in range(5)])

['$100', '$100', '$100', '$100', '$100']

>>> hsbc.crisis = True # crisis is coming, no more money!

>>> print(corner_street_atm.next())



>>> wall_street_atm = hsbc.create_atm() # it's even true for new ATMs

>>> print(wall_street_atm.next())



>>> hsbc.crisis = False # trouble is, even post-crisis the ATM remains empty

>>> print(corner_street_atm.next())



>>> brand_new_atm = hsbc.create_atm() # build a new one to get back in business

>>> for cash in brand_new_atm :

...    print cash

$100

$100

$100

$100

$100

$100

$100

$100

$100

...

对于控制一些资源的访问来说这很有用。

Itertools,你最好的朋友

itertools包含了很多特殊的迭代方法。是不是曾想过复制一个迭代器?串联两个迭代器？把嵌套的链表分组？不用创造一个新的链表的 zip/map?[/quote]

只要 import itertools

需要个例子？让我们看看比赛中4匹马可能到达终点的先后顺序的可能情况:

>>> horses = [1, 2, 3, 4]

[quote]>> races = itertools.permutations(horses)

>>> print(races)



>>> print(list(itertools.permutations(horses)))

[(1, 2, 3, 4),

 (1, 2, 4, 3),

 (1, 3, 2, 4),

 (1, 3, 4, 2),

 (1, 4, 2, 3),

 (1, 4, 3, 2),

 (2, 1, 3, 4),

 (2, 1, 4, 3),

 (2, 3, 1, 4),

 (2, 3, 4, 1),

 (2, 4, 1, 3),

 (2, 4, 3, 1),

 (3, 1, 2, 4),

 (3, 1, 4, 2),

 (3, 2, 1, 4),

 (3, 2, 4, 1),

 (3, 4, 1, 2),

 (3, 4, 2, 1),

 (4, 1, 2, 3),

 (4, 1, 3, 2),

 (4, 2, 1, 3),

 (4, 2, 3, 1),

 (4, 3, 1, 2),

 (4, 3, 2, 1)]

了解迭代器的内部机理

迭代是一个实现可迭代对象(实现的是 __iter__() 方法)和迭代器(实现的是__next__() 方法)的过程。可迭代对象是你可以从其获取到一个迭代器的任一对象。迭代器是那些允许你迭代可迭代对象的对象。
更多见这个文章: http://effbot.org/zone/python-for-statement.htm
翻译编辑原文：http://pyzh.readthedocs.org/en/latest/the-python-yield-keyword-explained.html[/quote]

#!/usr/bin/env python

# encoding: utf-8



import readline,rlcompleter



[size=16]# Indenting

[/size]

class TabCompleter(rlcompleter.Completer):

    """Completer that supports indenting"""

    def complete(self, text, state):

        if not text:

            return ('    ', None)[state]

        else:

            return rlcompleter.Completer.complete(self, text, state)



readline.set_completer(TabCompleter().complete)



[size=16]# Add autocompletion

[/size]

if 'libedit' in readline.__doc__:

    readline.parse_and_bind("bind -e")

    readline.parse_and_bind("bind '\t' rl_complete")

else:

    readline.parse_and_bind("tab: complete")



[size=16]# Add history

[/size]

import os

histfile = os.path.join(os.environ["HOME"], ".pyhist")

try:

    readline.read_history_file(histfile)

except IOError:

    pass

import atexit

atexit.register(readline.write_history_file, histfile)

del histfile

随着Python在国内的发展，特别是在自动化运维领域，运维开发者99%使用python开发自动化运维平台；在软件行业里面使用python编程语言的公司会越来越多，那么在学习Python的过程中需要养成几个好习惯。

下面我给大家分享几条：

缩进

由于跟其他编程语言的区别性，缩进在python编程中显得十分重要；在Python的代码块中必须使用相同数目的行首缩进空格数，否则会造成脚本运行错误，提示你格式不正确之类的信息。因此，在使用python语言写脚本的时候，保证缩进的一致性相当重要。

空格

虽然在python编程过程中，空行并不是Python语法的必需部分，但是，保持函数之间或类的方法之间用空行分隔，可以使得代码看起来更加清晰明了，也有利于后期的代码维护或重构。

注释

注释相对经常使用编程语言的人来说应该不是很陌生吧，主要因为注释不仅使得阅读代码的人容易理解，也让代码作者更好地定位代码函数等。python跟其它语言一样，注释在一些该注释的地方，可以让效率事半功倍。

源代码

python作为完全开源的语言，代码对于任何人都可以随意浏览。这种方式可以更好地帮助人们发现有利精简扼要的代码，在很多方面可以省去不必要的时间，因为觉得合适可以直接拿过来使用或者简单修改。经常看一下好的源代码，不仅会让你学习别人的编程方式，还在另一方面大大的帮助你更好地学习。

编程思想

使用任何一门编程语言，都需要保持很好的编程思想，对python来说也是一样的。学会创造使用适合自己的编程思想是至关重要的，因此，去多读一些讲解编程思想之类的书籍来充实自己吧。

多实践

学习任何一门编程语言都需要多做多写多看，通过不同的项目，来让自己得到更好的锻炼，相信是一件很棒的事情。在业余时间，经常的去敲写一些代码，也是很有意思的。

兴趣

兴趣是成功的一半，兴趣促使你更好地去使用学习编程语言，而不单单为了忙碌的工作。很多创造出编程语言的人来说，正时因为兴趣的使然，才成就了如此好的一些编程语言。

什么是lambda？

lambda定义匿名函数，并不会带来程序运行效率的提高，只会使代码更简洁。为了减少单行函数的定义而存在的。

lambda的使用大量简化了代码，使代码简练清晰。但是值得注意的是，这会在一定程度上降低代码的可读性。如果不是非常熟悉Python的人也许会对此很难理解。

如果可以使用for...in...if来完成的，坚决不用lambda。

如果使用lambda，lambda内不要包含循环，如果有，宁愿定义函数来完成，使代码获得可重用性和更好的可读性。如果你对你就喜欢用lambda来做，那也无可厚非，但是有内置函数减弱了代码的可读性！

好了介绍完成了lambda，那就让我们来实际用一下，实例如下：

 
下面我们再来看看小米加上步枪的结合使用。
1、reduce + lambda
What is reduce？

Python中的reduce内建函数是一个二元操作函数，他用来将一个数据集合(列表，元组等)中的所有数据进行如下操作：传给reduce中的函数func() (必须是一个二元操作函数)先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，最后得到一个结果。

关于python reduce的详细解析，后续详细介绍，下面我们介绍一下reduce + lambda的应用案例：

 
2、map + lambda
What is map？

map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

格式：map(func, seq1[, seq2...] )

Python函数式编程中的map()函数是将func作用于seq中的每一个元素，并用一个列表给出返回值。如果func为None，作用同zip()。

详细应用code如下：

这里需要注意的是：升级到python3的时候，map函数有一个变化那就是，如果不在map前加上list，lambda函数根本就不会执行。

在python2中，map会直接返回结果：

而再python3下面，返回的就是一个map对象:

如果要得到结果，必须用list作用于这个map对象。
 
3、filter + map
What is filter？

filter()函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。最终一次性返回过滤后的结果。

和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

简单应用如下：

这里简单介绍一下python内置函数小米加步枪，更详细的介绍再会，打完收工！

The following guest post is provided by Artur Barseghyan, a web developer currently employed by Goldmund, Wyldebeast & Wunderliebe in The Netherlands.

Python is my personal (and primary) programming language of choice and also happens to be the primary programming language at my company. So, when starting to work with a new technology, I prefer to use a clean and easy (Pythonic!) API.

After studying tons of articles on the web, reading (and writing) white papers, and doing basic performance tests (sometimes hard if you’re on a tight schedule), my company recently selected Cloudera for our Big Data platform (including using Apache HBase as our data store for Apache Hadoop), with Cloudera Manager serving a role as “one console to rule them all.”

However, I was surprised shortly thereafter to learn about the absence of a working Python wrapper around the REST API for HBase (aka Stargate). I decided to write one in my free time, and the result, ladies and gentlemen, wasStarbase (GPL).

In this post, I will provide some code samples and briefly explain what work has been done on Starbase. I assume that reader of this blog post already has some basic understanding of HBase (that is, of tables, column families, qualifiers, and so on).

一、安装

Next, I’ll show you some frequently used commands and use cases. But first, install the current version of Starbase from CheeseShop (PyPi).

# pip install starbase

导入模块:

>>> from starbase import Connection

…and create a connection instance. Starbase defaults to 127.0.0.1:8000; if your settings are different, specify them here.

>>> c = Connection()

二、API 操作实例

2.1 显示所有的表
假设有两个现有的表名为table1和table2表,以下将会打印出来。

>>> c.tables()

['table1', 'table2']

2.2 表的设计操作
每当你需要操作的表,你需要先创建一个表的实例。
创建一个表实例(注意,在这一步骤中没有创建表):

>>> t = c.table('table3')

Create a new table:
Create a table with columns ‘column1′, ‘column2′, ‘column3′ (here the table is actually created):

>>> t.create('column1', 'column2', 'column3')

201

检查表是否存在：

>>> t.exists()

True

查看表的列：

>>> t.columns()

['column1', 'column2', 'column3']

将列添加到表,(‘column4’,‘column5’,‘column6’,‘column7’):

>>> t.add_columns('column4', 'column5', 'column6', 'column7')

200

删除列表，(‘column6’, ‘column7’):

>>> t.drop_columns('column6', 'column7')

201

删除整个表:

>>> t.drop()

200

2.3 表的数据操作
将数据插入一行:

>>> t.insert(

[quote]>>     'my-key-1',

>>>     {

>>>         'column1': {'key11': 'value 11', 'key12': 'value 12', 'key13': 'value 13'},

>>>         'column2': {'key21': 'value 21', 'key22': 'value 22'},

>>>         'column3': {'key32': 'value 31', 'key32': 'value 32'}

>>>     }

>>> )

200

请注意,您也可以使用“本地”的命名方式列和细胞(限定词)。以下的结果等于前面的例子的结果。

>>> t.insert(

>>>     'my-key-1a',

>>>     {

>>>         'column1:key11': 'value 11', 'column1:key12': 'value 12', 'column1:key13': 'value 13',

>>>         'column2:key21': 'value 21', 'column2:key22': 'value 22',

>>>         'column3:key32': 'value 31', 'column3:key32': 'value 32'

>>>     }

>>> )

200

更新一排数据：

>>> t.update(

>>>     'my-key-1',

>>>     {'column4': {'key41': 'value 41', 'key42': 'value 42'}}

>>> )

200

Remove a row cell (qualifier):

>>> t.remove('my-key-1', 'column4', 'key41')

200

Remove a row column (column family):

>>> t.remove('my-key-1', 'column4')

200 

Remove an entire row:

>>> t.remove('my-key-1')

200

Fetch a single row with all columns:

>>> t.fetch('my-key-1')

  {

      'column1': {'key11': 'value 11', 'key12': 'value 12', 'key13': 'value 13'},

      'column2': {'key21': 'value 21', 'key22': 'value 22'},

      'column3': {'key32': 'value 31', 'key32': 'value 32'}

  }

Fetch a single row with selected columns (limit to ‘column1′ and ‘column2′ columns):

>>> t.fetch('my-key-1', ['column1', 'column2'])

  {

      'column1': {'key11': 'value 11', 'key12': 'value 12', 'key13': 'value 13'},

      'column2': {'key21': 'value 21', 'key22': 'value 22'},

  }

Narrow the result set even more (limit to cells ‘key1′ and ‘key2′ of column `column1` and cell ‘key32′ of column ‘column3′):

>>> t.fetch('my-key-1', {'column1': ['key11', 'key13'], 'column3': ['key32']})

  {

      'column1': {'key11': 'value 11', 'key13': 'value 13'},

      'column3': {'key32': 'value 32'}

  }

Note that you may also use the native means of naming the columns and cells (qualifiers). The example below does exactly the same thing as the example above.

>>>  t.fetch('my-key-1', ['column1:key11', 'column1:key13', 'column3:key32'])

  {

      'column1': {'key11': 'value 11', 'key13': 'value 13'},

      'column3': {'key32': 'value 32'}

  }

If you set the perfect_dict argument to False, you’ll get the native data structure:

>>>  t.fetch('my-key-1', ['column1:key11', 'column1:key13', 'column3:key32'], perfect_dict=False)

{

    'column1:key11': 'value 11', 'column1:key13': 'value 13',

    'column3:key32': 'value 32'

}

2.4 对表数据批处理操作
Batch operations (insert and update) work similarly to routine insert and update, but are done in a batch. You are advised to operate in batch as much as possible.[/quote]

In the example below, we will insert 5,000 records in a batch:  

>>> data = {

[quote]>>     'column1': {'key11': 'value 11', 'key12': 'value 12', 'key13': 'value 13'},

>>>     'column2': {'key21': 'value 21', 'key22': 'value 22'},

>>> }

>>> b = t.batch()

>>> for i in range(0, 5000):

>>>     b.insert('my-key-%s' % i, data)

>>> b.commit(finalize=True)

{'method': 'PUT', 'response': [200], 'url': 'table3/bXkta2V5LTA='}

In the example below, we will update 5,000 records in a batch:

>>> data = {

>>>     'column3': {'key31': 'value 31', 'key32': 'value 32'},

>>> }

>>> b = t.batch()

>>> for i in range(0, 5000):

>>>     b.update('my-key-%s' % i, data)

>>> b.commit(finalize=True)

{'method': 'POST', 'response': [200], 'url': 'table3/bXkta2V5LTA='}

Note: The table batch method accepts an optional size argument (int). If set, an auto-commit is fired each the time the stack is full.
2.5 表数据搜索（行扫描）
A table scanning feature is in development. At the moment it’s only possible to fetch all rows from a table. The result set returned is a generator.[/quote]

注意：表数据扫描功能正在开发中。目前仅支持取出表中所有数据（Full Table Scan），暂不支持范围扫描（RowKey Range Scan），其结果以一个迭代器形式返回。

>>> t.fetch_all_rows()

就介绍到这里了，没有时间翻译，聽简单的英文！