您所在的位置： &
Python语法的相关规则中的DFA的相关内容的介绍
Python语法的相关规则中的DFA的相关内容的介绍
以下的文章是通过Lb_str代表具体符号的介绍来引出Graminit.c中定义了包括Python语法规则的DFA的相关是实际应用方案的介绍。
我们都知道Graminit.c中定义了其中有包括Python语法规则的相关实际应用的相关内容，其中也包括了一些典型的类型，你如果想知道是哪四种典型的类型的话，你就可以浏览以下的文章对其进行了解。
Graminit.c中定义了包括Python语法规则的DFA(Deterministic Finite Automaton)，关于DFA请参考Alfred V. Aho等人所著的Compilers: Principles, Techniques, and Tools一书。为了定义DFA，graminit.c引用了位于grammar.h中的一些类型：arc, state, dfa, grammar。
Label定义了从状态转移到另外一个状态所经过的边所对应的符号，可以是非终结符(Non-Terminal)，也可以是终结符(Terminal)。Label一定依附于一条或者多条边。Lb_type代表符号的类型，如终结符NAME，代表一个标示符，或者非终结符stmt，代表一个语句，等等。
Lb_str代表具体符号的内容。比如，label (NAME, &if&)表示当parser处于某个状态，如果遇到了&if&这个标示符，则移动另外一个状态。如果label是一个非终结符的话，情况则要复杂一些，需要跳转到该非终结符对应的另外一个DFA，请参看编译器相关书籍。
/*&A&label&of&an&arc&*/ &typedef&struct&{ &int&lb_ &char&*lb_ &}& &&
在Graminit.c中定义了包括Python语法规则的DFA中arc代表DFA中一个状态到另一个状态的弧/边。A_lbl代表arc所对应的Label，而a_arrow记录了arc的目标状态。因为arc是属于某个状态的，因此不用纪录arc的起始状态。
/*&An&arc&from&one&state&to&another&*/ &typedef&struct&{ &short&a_&/*&Label&of&this&arc&*/ &short&a_&/*&State&where&this&arc&goes&to&*/ &}& &
State代表着DFA中的状态节点。每个state记录了从该state出发的边的集合，存放在s_arc中。其他的一些成员s_lower, s_upper, s_accel, s_accept记录了state所对应的Accelerator，其作用会在后面讲述。注意Accelerator信息并没有定义在graminit.c中，而是在运行时计算出来的。
/*&A&state&in&a&DFA&*/ &typedef&struct&{ &int&s_ &arc&*s_&/*&Array&of&arcs&*/ &/*&Optional&accelerators&*/ &int&s_&/*&Lowest&label&index&*/ &int&s_&/*&Highest&label&index&*/ &int&*s_&/*&Accelerator&*/ &int&s_&/*&Nonzero&for&accepting&state&*/ &}& &&
DFA结构中记录了起始状态d_initial和所有状态的集合d_state。d_first记录了该DFA所对应的非终结符的firstset，也就是说，当遇到firstset中的终结符的时候，便需要跳转到此DFA中。d_first在后面计算Accelerators的时候会被用到。
/*&A&DFA&*/ &typedef&struct&{ &int&d_&/*&Non-terminal&this&represents&*/ &char&*d_&/*&For&printing&*/ &int&d_&/*&Initial&state&*/ &int&d_ &state&*d_&/*&Array&of&states&*/ &bitset&d_ &}& &&
Grammar代表了Python的整个语法，记录了所有的DFA和所有的label。G_start则是Python语法的起始symbol，一般是single_input。不过实际的起始symbol可以在创建Parser的时候指定，可以是single_input, file_input, eval_input中的一个。
【编辑推荐】
【责任编辑： TEL：（010）】
关于的更多文章
Python是一种即译式的，互动的，面向对象的编程语言，它包含了模
本次的专刊为大家提供了Oracle最新推出的Java SE 8详细的开发教程，从解读到探究Java 8最新
程序员的30岁，是个伤不起的现象。你不可能敲一辈子的
Hadoop Summit 2013 大会讲师 PPT 第二季重磅来袭！如
现在这天气到处都是高温，还是老老实实的呆在家里上网
本书重点讲解如何用实用的代码来解决具体的实际问题。本书的内容覆盖面很广，从新的C#范型到Web服务，从反射到安全等都有涉及。
51CTO旗下网站如何进行PYTHON语法检查？
[问题点数：100分，结帖人palluo]
如何进行PYTHON语法检查？
[问题点数：100分，结帖人palluo]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
相关帖子推荐：
2006年4月 其他开发语言大版内专家分月排行榜第三2004年12月 其他开发语言大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。6680人阅读
其实，Python是一种真正的动态语言，代码中的变量名本没有&声明&或&定义&的说法，语言本身也没有提供声明或定义变量的特殊语法（global除外）。对程序员来说，这是一种好处，也是一种危险，比如像下面这段代码：count = total = 1delta = 0.7while total & 1000:& total += delta * (count * count + delta * delta)& dalta = delta * 1.1& count *= daltaprint total代码后面的dalta是delta拼写错误的结果，程序可以正确运行，也可以通过pychecker工具的检查，但其输出显然与预期的正确结果相差甚远。不少人认为像Perl中的strict或Visual Basic中的Option Explicit可以帮助程序员减少出现类似错误的几率（尽管我自己并不这么想），但在Python中，因为没有显式定义或声明变量名的语法，这种强制检查似乎较难下手&&网上可以查到一些解决方案，但或者比较复杂，或者是用__slots__，decorator这样的机制来解决部分问题，用起来不太方便。也许，利用parser或compiler包提供的抽象语法树（Abstract Syntax Tree）可以比较简单地解决这个问题。我大致写了一段名为strict.py的代码。为了将自己的程序改为强制声明变量的&安全代码&，我们只需要按照strict.py的要求，用 __decl__ = &name1 name2 ...& 这样简单的语法在使用前预先声明变量名即可。例如，可以在上面那段危险代码的开头加上：__decl__ = &delta total count&然后用strict.py检查这段代码（假设其文件名为test.py）：python strict.py test.py我们可以在运行结果中看到：File 'test.py', line 6: name 'dalta' is not declared.瞧，很容易就把拼写错误的变量名 dalta 给找出来了&&因为 dalta 这个名字没有预先&声明&。strict.py也可以检查Class或Function等代码块内部的局部名字（ __decl__ = &...& 这样的声明语句可以用在代码中的任何位置），可以识别from ... import、global或函数参数表等引入的名字。像下面这样的代码：__decl__ = 'name1 name2 name3'name1 = 1name2 = 'Jack'name3 = name1 + 3def foo():& global name1& __decl__ = 'local_name1 local_name2'& name1 += 4& local_name1 = 1.2& local_name2 = 'Mike'& undeclared = 9strict.py可以很快找出其中的undeclared是&未声明&的名字。strict.py只检查那些作为赋值目标的名字（l-value），对于读取某个名字，调用某个函数名，通过 obj.attr 这样的语法访问对象的属性或成员等等情况，strict.py没有必要考虑&&因为如果这些情况中出现了未定义的名称，编译或运行程序时就会报出错误来，不会造成潜在的危险隐患。因为只是示例性质的代码，我只在Python 2.4.3的环境下测试过strict.py，也没有做更多复杂的测试。这段代码一定还有许多需要改进之处。先把strict.py的代码罗列在下面吧：strict.py------------------------------------------------------import sysimport compilerdeclaration_flag = &__decl__&def find_undeclared_names(ast, frames, is_decl):&&& next_frames = frames&&& def add_name(name):&&&&&&& frames[-1][name] = True&&& def find_name(name):&&&&&&& return frames[-1].has_key(name)&&& def get_alias(name_pair):&&&&&&& if name_pair[1] is None:&&&&&&&&&&& return name_pair[0]&&&&&&& else:&&&&&&&&&&& return name_pair[1]&&& if ast.__class__.__name__ == &AssName&:&&&&&&& if not is_decl[0] and ast.name == declaration_flag:&&&&&&&&&&& is_decl[0] = True&&&&&&& elif not find_name(ast.name):&&&&&&&&&&& yield ast.name, ast.lineno&&& elif ast.__class__.__name__ == &Global&:&&&&&&& map(add_name, ast.names)&&& elif ast.__class__.__name__ == &From&:&&&&&&& if (ast.names[0][0] == &*&):&&&&&&&&&&& mod = __import__(ast.modname)&&&&&&&&&&& map(add_name, filter(lambda x:not x.startswith('_'), dir(mod)))&&&&&&& else:&&&&&&&&&&& map(add_name, map(get_alias, ast.names))&&& elif ast.__class__.__name__ == &Const&:&&&&&&& if is_decl[0] and ast.value.__class__.__name__ == &str&:&&&&&&&&&&& map(add_name, ast.value.split())&&&&&&&&&&& is_decl[0] = False&&& elif ast.__class__.__name__ == &Function&:&&&&&&& next_frames = frames + [dict(map(lambda x: (x, True), ast.argnames))]&&& elif ast.__class__.__name__ == &Class&:&&&&&&& next_frames = frames + [{}]&&& for childNode in ast.getChildNodes():&&&&&&& for x in find_undeclared_names(childNode, next_frames, is_decl):&&&&&&&&&&& yield xif __name__ == &__main__&:&&& if len(sys.argv) != 2:&&&&&&& print &Usage: python strict.py &python-source-file&&&&& else:&&&&&&& for name, line_no in /&&&&&&&&&&&&&&& find_undeclared_names(compiler.parseFile(sys.argv[1]),&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& [{}],&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& [False]):&&&&&&&&&&& print &File '%s', line %d: name '%s' is not declared.& % /&&&&&&&&&&&&&&&&& (sys.argv[1], line_no, name)
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：386340次
积分：5059
积分：5059
排名：第2333名
原创：78篇
评论：591条
(1)(1)(6)(3)(3)(1)(3)(3)(1)(1)(5)(6)(3)(1)(3)(7)(3)(4)(6)(6)(13)Python程序员的10个常见错误 - 博客 - 伯乐在线
& Python程序员的10个常见错误
| 分类： ,
关于Python
是一门解释性的，面向对象的，并具有动态语义的高级编程语言。它高级的内置数据结构，结合其动态类型和动态绑定的特性，使得它在快速应用程序开发（）中颇为受欢迎，同时Python还能作为脚本语言或者胶水语言讲现成的组件或者服务结合起来。Python支持模块（modules）和包（packages），所以也鼓励程序的模块化以及代码重用。
Python简单、易学的语法可能会误导一些Python程序员（特别是那些刚接触这门语言的人们），可能会忽略某些细微之处和这门语言的强大之处。
考虑到这点，本文列出了“十大”甚至是高级的Python程序员都可能犯的，却又不容易发现的细微错误。（注意：本文是针对比《》稍微高级一点读者，对于更加新手一点的Python程序员，有兴趣可以读一读那篇文章）
常见错误1：在函数参数中乱用表达式作为默认值
Python允许给一个函数的某个参数设置默认值以使该参数成为一个可选参数。尽管这是这门语言很棒的一个功能，但是这当这个默认值是可变对象（）时，那就有些麻烦了。例如，看下面这个Python函数定义：
&&& def foo(bar=[]):
# bar是可选参数，如果没有指明的话，默认值是[]
bar.append(&baz&)
# 但是这行可是有问题的，走着瞧…
return bar
人们常犯的一个错误是认为每次调用这个函数时不给这个可选参数赋值的话，它总是会被赋予这个默认表达式的值。例如，在上面的代码中，程序员可能会认为重复调用函数foo() （不传参数bar给这个函数），这个函数会总是返回‘baz’，因为我们假定认为每次调用foo()的时候（不传bar），参数bar会被置为[]（即，一个空的列表）。
那么我们来看看这么做的时候究竟会发生什么：
[&baz&, &baz&]
[&baz&, &baz&, &baz&]
嗯？为什么每次调用foo()的时候，这个函数总是在一个已经存在的列表后面添加我们的默认值“baz”，而不是每次都创建一个新的列表？
答案是一个函数参数的默认值，仅仅在该函数定义的时候，被赋值一次。如此，只有当函数foo()第一次被定义的时候，才讲参数bar的默认值初始化到它的默认值（即一个空的列表）。当调用foo()的时候（不给参数bar），会继续使用bar最早初始化时的那个列表。
由此，可以有如下的解决办法：
&&& def foo(bar=None):
if bar is None:
# 或者用 if not bar:
bar.append(&baz&)
return bar
常见错误2：不正确的使用类变量
看下面一个例子：
&&& class A(object):
&&& class B(A):
&&& class C(A):
&&& print A.x, B.x, C.x
看起来没有问题。
&&& B.x = 2
&&& print A.x, B.x, C.x
嗯哈，还是和预想的一样。
&&& A.x = 3
&&& print A.x, B.x, C.x
我了个去。只是改变了A.x，为啥C.x也变了？
在Python里，类变量通常在内部被当做字典来处理并遵循通常所说的方法解析顺序（）。因此在上面的代码中，因为属性x在类C中找不到，因此它会往上去它的基类中查找（在上面的例子中只有A这个类，当然Python是支持多重继承（multiple inheritance）的）。换句话说，C没有它自己独立于A的属性x。因此对C.x的引用实际上是对A.x的引用。（B.x不是对A.x的引用是因为在第二步里B.x=2将B.x引用到了2这个对象上，倘若没有如此，B.x仍然是引用到A.x上的。——译者注）
常见错误3：在异常处理时错误的使用参数
假设你有如下的代码：
l = [&a&, &b&]
... except ValueError, IndexError:
# 想捕捉两个异常
Traceback (most recent call last):
File &&stdin&&, line 3, in &module&
IndexError: list index out of range
这里的问题在于except语句不会像这样去接受一系列的异常。并且，在Python 2.x里面，语法except Exception, e是用来将异常和这个可选的参数绑定起来（即这里的e），以用来在后面查看的。因此，在上面的代码中，IndexError异常不会被except语句捕捉到；而最终ValueError这个异常被绑定在了一个叫做IndexError的参数上。
在except语句中捕捉多个异常的正确做法是将所有想要捕捉的异常放在一个元组（）里并作为第一个参数给except语句。并且，为移植性考虑，使用as关键字，因为Python 2和Python 3都支持这样的语法，例如：
l = [&a&, &b&]
... except (ValueError, IndexError) as e:
常见错误4：误解Python作用域的规则
Python的作用域解析是基于叫做（Local（本地），Enclosing（封闭），Global（全局），Built-in（内置））的规则进行操作的。这看起来很直观，对吧？事实上，在Python中这有一些细微的地方很容易出错。看这个例子：
&&& x = 10
&&& def foo():
Traceback (most recent call last):
File &&stdin&&, line 1, in &module&
File &&stdin&&, line 2, in foo
UnboundLocalError: local variable 'x' referenced before assignment
这是怎么回事？
这是因为，在一个作用域里面给一个变量赋值的时候，Python自动认为这个变量是这个作用域的本地变量，并屏蔽作用域外的同名的变量。
很多时候可能在一个函数里添加一个赋值的语句会让你从前本来工作的代码得到一个UnboundLocalError。（感兴趣的话可以读一读文章。）
在使用列表（）的时候，这种情况尤为突出。看下面这个例子：
&&& lst = [1, 2, 3]
&&& def foo1():
lst.append(5)
# 这没有问题...
&&& foo1()
[1, 2, 3, 5]
&&& lst = [1, 2, 3]
&&& def foo2():
lst += [5]
# ... 这就有问题了！
&&& foo2()
Traceback (most recent call last):
File &&stdin&&, line 1, in &module&
File &&stdin&&, line 2, in foo
UnboundLocalError: local variable 'lst' referenced before assignment
嗯？为什么foo2有问题，而foo1没有问题？
答案和上一个例子一样，但是更加不易察觉。foo1并没有给lst赋值，但是foo2尝试给lst赋值。注意lst+=[5]只是lst=lst+[5]的简写，由此可以看到我们尝试给lst赋值（因此Python假设作用域为本地）。但是，这个要赋给lst的值是基于lst本身的（这里的作用域仍然是本地），而lst却没有被定义，这就出错了。
常见错误5：在遍历列表的同时又在修改这个列表
下面这个例子中的代码应该比较明显了：
&&& odd = lambda x : bool(x % 2)
&&& numbers = [n for n in range(10)]
&&& for i in range(len(numbers)):
if odd(numbers[i]):
del numbers[i]
# 这不对的：在遍历列表时删掉列表的元素。
Traceback (most recent call last):
File &&stdin&&, line 2, in &module&
IndexError: list index out of range
遍历一个列表或者数组的同时又删除里面的元素，对任何有经验的软件开发人员来说这是个很明显的错误。但是像上面的例子那样明显的错误，即使有经验的程序员也可能不经意间在更加复杂的程序中不小心犯错。
所幸，Python集成了一些优雅的编程范式，如果使用得当，可以写出相当简化和精简的代码。一个附加的好处是更简单的代码更不容易遇到这种“不小心在遍历列表时删掉列表元素”的bug。例如列表推导式（）就提供了这样的范式。再者，列表推导式在避免这样的问题上特别有用，接下来这个对上面的代码的重新实现就相当完美：
&&& odd = lambda x : bool(x % 2)
&&& numbers = [n for n in range(10)]
&&& numbers[:] = [n for n in numbers if not odd(n)]
# 啊，这多优美
&&& numbers
[0, 2, 4, 6, 8]
常见错误6：搞不清楚在闭包（closures）中Python是怎样绑定变量的
看这个例子：
&&& def create_multipliers():
return [lambda x : i * x for i in range(5)]
&&& for multiplier in create_multipliers():
print multiplier(2)
期望得到下面的输出：
但是实际上得到的是：
这是由于Python的后期绑定（late binding）机制导致的，这是指在闭包中使用的变量的值，是在内层函数被调用的时候查找的。因此在上面的代码中，当任一返回函数被调用的时候，i的值是在它被调用时的周围作用域中查找（到那时，循环已经结束了，所以i已经被赋予了它最终的值4）。
解决的办法比较巧妙：
&&& def create_multipliers():
return [lambda x, i=i : i * x for i in range(5)]
&&& for multiplier in create_multipliers():
print multiplier(2)
这下对了！这里利用了默认参数去产生匿名函数以达到期望的效果。有人会说这很优美，有人会说这很微妙，也有人会觉得反感。但是如果你是一名Python程序员，重要的是能理解任何的情况。
常见错误7：循环加载模块
假设你有两个文件，a.py和b.py，在这两个文件中互相加载对方，例如：
在a.py中：
return b.x
在b.py中：
print a.f()
首先，我们试着加载a.py：
&&& import a
没有问题。也许让人吃惊，毕竟有个感觉应该是问题的循环加载在这儿。
事实上在Python中仅仅是表面上的出现循环加载并不是什么问题。如果一个模块以及被加载了，Python不会傻到再去重新加载一遍。但是，当每个模块都想要互相访问定义在对方里的函数或者变量时，问题就来了。
让我们再回到之前的例子，当我们加载a.py时，它再加载b.py不会有问题，因为在加载b.py时，它并不需要访问a.py的任何东西，而在b.py中唯一的引用就是调用a.f()。但是这个调用是在函数g()中完成的，并且a.py或者b.py中没有人调用g()，所以这会儿心情还是美丽的。
但是当我们试图加载b.py时（之前没有加载a.py），会发生什么呢：
&&& import b
Traceback (most recent call last):
File &&stdin&&, line 1, in &module&
File &b.py&, line 1, in &module&
File &a.py&, line 6, in &module&
File &a.py&, line 4, in f
return b.x
AttributeError: 'module' object has no attribute 'x'
恭喜你，出错了。这里问题出在加载b.py的过程中，Python试图加载a.py，并且在a.py中需要调用到f()，而函数f()又要访问到b.x，但是这个时候b.x却还没有被定义。这就产生了AttributeError异常。
解决的方案可以做一点细微的改动。改一下b.py，使得它在g()里面加载a.py：
import a # 只有当g()被调用的时候才加载
print a.f()
这会儿当我们加载b.py的时候，一切安好：
&&& import b
1 # 第一次输出，因为模块a在最后调用了‘print f()’
1 # 第二次输出，这是我们调用g()
常见错误8：与Python标准库模块命名冲突
Python的一个优秀的地方在于它提供了丰富的库模块。但是这样的结果是，如果你不下意识的避免，很容易你会遇到你自己的模块的名字与某个随Python附带的标准库的名字冲突的情况（比如，你的代码中可能有一个叫做email.py的模块，它就会与标准库中同名的模块冲突）。
这会导致一些很粗糙的问题，例如当你想加载某个库，这个库需要加载Python标准库里的某个模块，结果呢，因为你有一个与标准库里的模块同名的模块，这个包错误的将你的模块加载了进去，而不是加载Python标准库里的那个模块。这样一来就会有麻烦了。
所以在给模块起名字的时候要小心了，得避免与Python标准库中的模块重名。相比起你提交一个“”去向上要求改一个标准库里包的名字，并得到批准来说，你把自己的那个模块重新改个名字要简单得多。
常见错误9：不能区分Python 2和Python 3
看下面这个文件foo.py：
import sys
def bar(i):
if i == 1:
raise KeyError(1)
if i == 2:
raise ValueError(2)
def bad():
bar(int(sys.argv[1]))
except KeyError as e:
print('key error')
except ValueError as e:
print('value error')
在Python 2里，运行起来没有问题：
$ python foo.py 1
$ python foo.py 2
value error
但是如果拿到Python 3上面玩玩：
$ python3 foo.py 1
Traceback (most recent call last):
File &foo.py&, line 19, in &module&
File &foo.py&, line 17, in bad
UnboundLocalError: local variable 'e' referenced before assignment
这是怎么回事？“问题”在于，在Python 3里，在except块的作用域以外，异常对象（exception object）是不能被访问的。（原因在于，如果不这样的话，Python会在内存的堆栈里保持一个引用链直到Python的垃圾处理将这些引用从内存中清除掉。更多的技术细节可以参考。）
避免这样的问题可以这样做：保持在execpt块作用域以外对异常对象的引用，这样是可以访问的。下面是用这个办法对之前的例子做的改动，这样在Python 2和Python 3里面都运行都没有问题。
import sys
def bar(i):
if i == 1:
raise KeyError(1)
if i == 2:
raise ValueError(2)
def good():
exception = None
bar(int(sys.argv[1]))
except KeyError as e:
exception = e
print('key error')
except ValueError as e:
exception = e
print('value error')
print(exception)
在Py3k里面运行：
$ python3 foo.py 1
$ python3 foo.py 2
value error
（顺带提一下，我们的“”里讨论了从Python 2移植代码到Python 3时需要注意的其他重要的不同之处。）
常见错误10：错误的使用__del__方法
假设有一个文件mod.py中这样使用：
import foo
class Bar(object):
def __del__(self):
foo.cleanup(self.myhandle)
然后试图在another_mod.py里这样：
import mod
mybar = mod.Bar()
那么你会得到一个恶心的AttributeError异常。
为啥呢？这是因为（参考），当解释器关闭时，模块所有的全局变量会被置为空（None）。结果便如上例所示，当__del__被调用时，名字foo已经被置为空了。
使用atexit.register()可以解决这个问题。如此，当你的程序结束的时候（退出的时候），你的注册的处理程序会在解释器关闭之前处理。
这样理解的话，对上面的mod.py可以做如下的修改：
import foo
import atexit
def cleanup(handle):
foo.cleanup(handle)
class Bar(object):
def __init__(self):
atexit.register(cleanup, self.myhandle)
这样的实现方式为在程序正常终止时调用清除功能提供了一种干净可靠的办法。显然，需要foo.cleanup决定怎么处理绑定在self.myhandle上的对象，但你知道怎么做的。
Python 是一门非常强大且灵活的语言，它众多的机制和范式能显著的提高生产效率。不过，和任何一款软件或者语言一样，对它的理解或认识不足的话，常常是弊大于利的，并会处于一种“一知半解”的状态。
多熟悉Python的一些关键的细微的地方，比如（但不局限于）本文中提到的这些问题，可以帮你更好的使用这门语言的同时帮你避免一些常见的陷阱。
感兴趣的话可以读一读这篇“”，了解一些能够区分Python程序员的面试题目。
希望您能在本文学到有用的地方，并欢迎您的反馈。
关于作者：
为作者带来更多读者；为读者筛选优质内容；专注IT互联网。
最新评论（期待您也参与评论）
汇集优质的Python技术文章和资源。人生苦短，我用Python！
JavaScript, CSS, HTML5 这里有前端的技术干货！
关注安卓移动开发业界动态，分享技术文章和优秀工具资源。
关注iOS移动开发业界动态，分享技术文章和优秀工具资源。
为作者带来更多读者；为读者筛选优质内容；专注IT互联网。
由数百名译者组成，立志翻译传播优秀的外文技术干货。
一个专门为IT单身男女服务的征婚传播平台。
收录优秀的工具资源，覆盖开发、设计、产品和管理等。
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线博客团队正试图以我们微薄的力量，把优秀的原创/译文分享给读者，做一个小而精的精选博客，为“快餐”添加一些“营养”元素。
欢迎关注更多频道
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选博客文章
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
（加好友请注明来意）
网站使用问题
请在询问或者反馈
& 2015 伯乐在线
赞助云主机， 赞助云存储}