说明：本文内容全部出自python官方文档，但是会有自己的理解，并非单纯的翻译。文章较长，如有错误之处，还请大家指正。

abs(x)
返回x的绝对值；当x是复数时，返回x的模。没错，python内建支持复数，见下面的complex()函数。

all(iterable)
当iterable里的每项都为真时，才返回真，等效于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any(iterable)
只要iterable里有一项为真，就返回真，等效于：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

basestring()
这是 str 和 unicode 的抽象类，它不能被调用也不能被实例化，但是可以用在 isinstance 函数里进行判断，isinstance(obj, basestring) 等效于 isinstance(obj, (str, unicode)).

>>> isinstance(123, basestring)
False
>>> isinstance("123", basestring)
True
>>> isinstance(u"一二三", basestring)
True

bin(x)
如果x是一个整数，则返回一个与x等值的二进制python表达式；如果x不是一个整数类型，则x的类需要有一个可以返回一个整数的__index__()函数。

bool([x])
返回一个布尔型的值，如果x为False或者没传x参数的时候返回False，否则返回True。

callable(object)
判断object是否可调用，如果object是 函数、类、或者含有__call__()的类对象的话，将返回True。

chr(i)
返回一个单个字符的字符串，此字符的ascii码值为i(0<=i<=255)，此函数是ord函数的反函数。如果参数大于255而想得到一个unicode字符的话，需要使用unichr()

classmethod(function)
返回一个类的方法（类的方法有别于实例的方法，是不需要实例化也可以通过类名访问的方法），定义一个类的方法需要用这样的形式：

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

cmp(x, y)
比较两个对象x和y。如果x小于y，返回负数；大于返回正数；等于返回0。

compile(source, filename, mode[, flags[, dont_inherit]])
把source字符串编译成一个AST对象，暂时用不到，先略过。

complex([real[, imag]])
用传入的实部和虚部创建一个复数对象。

delattr(object, name)
删除对象的属性，相当于 del object.name ，可以和setattr配合使用。

dict([arg])
建立一个新的字典型数据，可以从参数里获取数据。

>>> dict({"a":"b","c":"d"})
{'a': 'b', 'c': 'd'}

dir([object])
如果不加参数，返回当前执行环境下的变量名的列表。
如果加了object参数，则会根据复杂的规则得到object的属性名列表，需要注意的是，当object定义了__dir__()或者 __getattr__()方法时，返回的结果并不一定正确。
示例：

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']
>>> t=[1,2]
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 't']
>>> dir(t)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

divmod(a, b)
通常返回a和b的商和余数组成的元组： (a // b, a % b)。参数不能是复数。

enumerate(sequence[, start=0])
返回一个列举后的对象，sequence要支持迭代。返回的对象支持next()方法，此方法依次返回一个从start开始增长的序数和sequence里的元素组成的元组。看以下的例子：

>>> enu=enumerate(['Spring', 'Summer', 'Fall', 'Winter'])
>>> enu.next()
(0, 'Spring')
>>> enu.next()
(1, 'Summer')
>>> for i, season in enu:
...     print i, season
... 
2 Fall
3 Winter

eval(expression[, globals[, locals]])
执行expression表达式，可以用globals和locals来限制expression能访问的变量。
值得注意的是，expression不仅可以是明文的字符串，还可以是compile()函数返回的代码对象。

execfile(filename[, globals[, locals]])
此函数类似exec表达式。只是从文件里读取表达式。它和import的区别在于，execfile会无条件地读取文件，而且不会生成新的模块。
globals和locals的用法和上面的eval同理。

file(filename[, mode[, bufsize]])
File类型的构造函数，参数的作用和下面提到的open()函数是一样的。
值得注意的是，open()函数更适合于打开一个文件，而file函数更适用于类型测试，例如： isinstance(f, file)

filter(function, iterable)
构造一个function(iterable)为true的list。当然iterable为字符串或者tuple的时候，返回的类型也是字符串或者tuple，否则返回list。

>>> filter(lambda c: c in 'abc', 'abcdcba')
'abccba'
>>> filter(lambda i: i < 3, (1, 2, 3, 2, 1))
(1, 2, 2, 1)
>>> filter(lambda i: i < 3, [1, 2, 4, 2, 1])
[1, 2, 2, 1]

如果function为None，则iterable为false的元素将被剔除。也就是说，function不为None的时候，filter(function, iterable)等效于[item for item in iterable if function(item)]，否则等效于[item for item in iterable if item]

float([x])
传入一个字符串或者整数或者float，返回一个float数据。

format(value[, format_spec])
根据format_spec格式化输出value的值，实际上只是调用了value.__format__(format_spec)，很多内建类型都有标准的输出函数。

frozenset([iterable])
由iterable创建一个frozenset对象，frozenset是set的一个子类，它和set的区别在于它不支持某些可以修改set的操作，例如：add、remove、pop、clear等。可以理解为一个set的常量。

getattr(object, name[, default])
获得对象的属性值，name必须是字符串，如果name是object的属性，则getattr(x, 'foobar')相当于x.foobar，如果name不是object的属性，则返回default，如果没有default就会抛出AttributeError意外。

globals()
返回一个包含当前“全局符号表”的dict。

hasattr(object, name)
参数是一个对象和一个字符串，如果object对象有名为name的属性，则返回True，否则返回False。在执行getattr(object, name)之前，可以以此来检测属性的存在性。

hash(object)
如果可能的话，返回object的hash值，hash值是一个整型的数字，用于快速比较两个对象。两个相等的数字型对象将有相同的hash值，比如：

>>> hash(1) == hash(1.0)
True

help([object])
调用内建的帮助系统（交互式）。
如果省略参数，则会进入帮助控制台，出现help>的提示符，输入相应内容就可以查看相应的帮助。
如果参数是字符串，则在模块名、函数名、类名、方法名、关键字及文档和帮助主题里搜索此字符串，并显示。
如果参数是其他类型的对象，则显示此对象的帮助信息。

hex(x)
将任何长度的整型数字转化为16进制的字符串。
如果转换浮点数为16进制，则须使用float.hex()方法。

id(object)
返回一个整型（或者长整型）的object的唯一标识符。注意：两个生命周期没有交叉的对象，也许会返回同一个标识符。（在CPython里，其实就是返回object的地址）

input([prompt])
等效于 eval(raw_input(prompt))
返回用户输入的python表达式的值，一句话：注意安全。

int([x[, base]])
根据x的值返回一个整数，x可以是一个含有数字信息的字符串或者数字类型（整型/浮点型/长整型/复数）。可选的base参数，代表进制，可以是2~36之间的数字或者0。如果base的值为0，将会根据x的值选取适当的基数。如果不提供任何参数，将返回0。

isinstance(object, classinfo)
如果object是classinfo或者classinfo的子类的实例，或者是和classinfo同类的对象，则返回True。classinfo也可以是类或者对象组成的tuple，这时候，object只要是classinfo里的一者就返回True：

>>> isinstance(1, (int,float) )
True
>>> isinstance(1.0, (int,float) )
True
>>> isinstance("1.0", (int,float) )
False

issubclass(class, classinfo)
如果class是classinfo的直接或者间接之类的话，就返回True。一个类也被视为自己的之类。同上例，classinfo也可以是tuple。

iter(o[, sentinel])
返回一个“迭代器”对象，根据sentinel的设置不停地对第一个参数进线取值。当忽略第二个参数时，o必须是一个支持__iter__()或者__getitem__()方法的对象，否则将会抛出TypeError例外。如果提供了sentinel参数，o必须是一个可调用的对象，这时将不停地调用此方法，并返回迭代器的项，知道返回的值等于sentinel为止，这时将抛出StopIteration。
第二种形式特别适用于打开一个文件，一行行处理文本，知道遇到特定的行：

with open("mydata.txt") as fp:
    for line in iter(fp.readline, "STOP"):
        process_line(line)

len(s)
返回s的长度，也就是项数。自建会调用__len__函数取值。

list([iterable])
返回一个含有所有iterable中的元素的list对象。如果参数为空，则返回空的list。

locals()
和上面的globals()对应，返回一个包含当前“局部符号表”的dict。在函数里调用的时候，将排除在类中声明的变量。

long([x[, base]])
根据字符串或者数字类型的参数，返回一个长整型的数字。参数的含义和上面的int类似。

map(function, iterable, …)
对iterable里的每项执行function函数，并把结果以一个list的形式返回。如果有3个以上的参数，则后面的参数也需要是可迭代的，map会把额外的参数传给function，例如，这样可以把两个tuple一一相加得到一个list：

>>> map(lambda x, add: x + add, (2, 4, 5), (1, 3, 6) )
[3, 7, 11]

如迭代器的长度不一致，缺失的项将用None代替：

>>> map(lambda x, add: x + add, (2, 4, 5), (1, 3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <lambda>
TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

如果function为None，将用 identity function 代替（好像就是直入直出）。

max(iterable[, args…][, key])
如果只给一个参数，就返回iterable里最大的项；如果是多个参数的话，则返回参数里最大的项。

>>> max("abcd")
'd'
>>> max(1, 2, 3)
3

额外的key参数，是用于比较的函数，比如，下面这个可以得到各项除3的余数最大的一个：

>>> max([1, 2, 3, 4], key=lambda x: x % 3)
2

min(iterable[, args…][, key])
同上，求最小值。

next(iterator[, default])
依次返回迭代器iterator的项。当iterator没有更多的项时，如果有default参数，则返回default，否则抛出StopIteration例外。

>>> a = iter(range(3))
>>> next(a)
0
>>> next(a)
1
>>> next(a)
2
>>> next(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> next(a, "No More Item...")
'No More Item...'

object()
返回一个空的对象，但是此对象会有一些公有的属性：

>>> o = object()
>>> dir(o)
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

oct(x)
将任意精度的十进制整数x转换成八进制。

open(filename[, mode[, bufsize]])
打开文件，返回一个文件对象，如果文件打不开，将抛出IOError错误。
filename参数，是要打开的文件名。
mode参数是打开方式，通常是'r'表示读，'w'表示写（如果已存在则会覆盖），'a'表示追加。缺省为'r'。另外，缺省使用的是文本模式，会把'\n'转成系统相关的换行符，如果要避免这个引起的问题，需要在各个模式后面加一个'b'表示使用二进制模式。另外还有些’+uU’之类的模式，不常用，也就不介绍了吧。
可选的bufsize参数表示缓冲区的大小。0表示不缓冲，1表示行缓冲，其他正数表示近视的缓冲区字节数，负数表示使用系统默认值。默认是0。

ord(c)
给定一个长度为1的字符串或者unicode字符，返回该字符的ascii码或者unicode码，前一种情况是chr()的反函数，后一种情况是unichr()的反函数。

pow(x, y[, z])
返回x的y次方，也就是x**y。如果有z的话，返回x的y次方除z得到的余数（这个比pow(x, y) % z更高效，这点可以看我写的欧拉工程第48题的代码，之前很慢，现在很快）。
如果第二个参数是负数的话，将返回浮点型的数据，而且这个时候不能有z。

print([object, …][, sep=’ ‘][, end=’\n’][, file=sys.stdout])
输出一个或多个object到file，中间用sep间隔，并在结尾加上end。
后3个参数如果给出的话，必须用keyword arguments的形式，也就是必须指定参数名，否则将一概被视为object的一部分而被输出。
需要注意的是和python 2.6前的print关键字的区别。

property([fget[, fset[, fdel[, doc]]]])
返回一个属性，参数分别是获取、设置和删除的函数外加doc string，看例子吧：

>>> class C(object):
...     def __init__(self):
...         self._x = None
...     def getx(self):
...         print "OK. give you:", self._x
...         return self._x
...     def setx(self, value):
...         print "Now x is:", value
...         self._x = value
...     def delx(self):
...         del self._x
...     x = property(getx, setx, delx, "I'm the 'x' property.")
... 
>>> a = C()
>>> a.x = 123
Now x is: 123
>>> print a.x
OK. give you: 123
123
>>> help(a.x)
OK. give you: 123
 
>>> help(C.x)
#这里可以看到I'm the 'x' property.

range([start], stop[, step])
方便地产生一个包含等差数列的list，如果忽略start，则默认为0；如果忽略step，则默认为1。经常被用于for循环里。注意返回的结果并不包含stop。

raw_input([prompt])
从输入读入一行字符串，结尾的回车将被去掉。如果提供了prompt参数，将做为输入的提示符。

reduce(function, iterable[, initializer])
将两个参数的function函数循环应用到迭代器的各项，例如reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])相当于((((1+2)+3)+4)+5)。如果提供了可选的initializer参数，则会将它放在迭代器的前面进行运算。

reload(module)
重新加载之前已经导入的模块。当你在设计一个模块，并用外部编辑器更新了它的代码时，可以用reload重新导入此模块，来验证模块的正确性。
reload执行时候的具体细节这里就不描述了。

repr(object)
返回一个尽量包含object的信息的字符串，其实交互式python解释器，在输入一个对象回车的时候，就是返回对象的repr值。
对于很多常见的对象，返回的值都尽可能地使得能够被eval解释并返回对象本身；另外的就尽量包含所在的域信息和类型或者地址等。
一个类可以通过__repr__()方法自定义repr的返回值。

reversed(seq)
返回一个倒序的迭代器。seq要么支持 __reversed__() 方法，要么支持取项的操作（也就是支持__len__()方法和从0开始的整数值的__getitem__()方法）。
例子：

>>> reversed(range(5))
<listreverseiterator object at 0x80a658c>
>>> [i for i in reversed(range(5))]
[4, 3, 2, 1, 0]

round(x[, n])
将浮点数x四舍五入取整到小数点后n位小数。n的默认值是0，也就是取整。

set([iterable])
由迭代器iterable返回一个集合对象，集合中的元素是随机顺序，但是不重复的。此函数在去掉列表的重复项的时候，特别有用：

>>> l = [1, 2, 3, 2, 4, 3]
>>> set(l)
set([1, 2, 3, 4])
>>> list(set(l))
[1, 2, 3, 4]
>>> ''.join(set("hello"))
'helo'

setattr(object, name, value)
此函数和getattr()配合使用，setattr(x, 'foobar', 123)相当于x.foobar = 123。

slice([start], stop[, step])
返回一个分片对象，分片对象就只包含了start, stop, step这3个信息，它在python内部和一些第三方库中广泛被使用，其实类似a[1:3]这样的操作也会生成分片对象。如果省略start和step，将默认为None。
可以看到下面两者其实是等效的：

>>> range(5)[slice(1, 4, 2)]
[1, 3]
>>> range(5)[1:4:2]
[1, 3]

sorted(iterable[, cmp[, key[, reverse]]])
返回一个排序后的列表，用于排序的元素来自iterable，后面的参数控制排序的过程。
cmp是自定义的比较函数，接受两个参数，返回负数表示第一个参数较小，返回0表示两者一样大，返回正数表示第一个参数较大。
key可以理解为每个参数的求值函数。如果提供了key，则在比较前，先对每个先用key进线求职，对结果再进行排序，但是返回的排序后的结果还是之前的值。
reverse如果是True，则按降序排列，默认是从小到大的升序。
看例子：

#正常的排序
>>> sorted([1, 5, 3, 4, 6])
[1, 3, 4, 5, 6]
#倒序
>>> sorted([1, 5, 3, 4, 6], reverse=True)
[6, 5, 4, 3, 1]
#提供了key，结果是除3的余数谁最小，谁就排前
>>> sorted([1, 5, 3, 4, 6], key=lambda x: x%3)
[3, 6, 1, 4, 5]
#用cmp实现的版本
>>> sorted([1, 5, 3, 4, 6], cmp=lambda x,y: x%3 - y%3)
[3, 6, 1, 4, 5]

值得注意的是，虽然cmp和key都可以实现上面的除3余数排列，但是因为cmp要对每次比较的两个元素都调用一次函数，所以，效率不如key来得高。

staticmethod(function)
返回一个静态方法function
要声明一个静态方法，需要使用如下的语法：

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

静态方法可以被类本身调用（例如：C.f()）也可以被类的对象调用（例如：C().f()）。

str([object])
返回一个精确可打印的字符串，来说明object。和repr(object)不同，str(object)返回的字符串不一定能被eval()执行来得到对象本身，str(object)的目标只是可打印和可读。

sum(iterable[, start])
对iterable在start做为初值的基础上进行累加。start的默认值为0。
注意此方法不能对字符串进行相加（连接）操作，连接字符串还是用''.join(sequence)好了。另外，sum(range(n), m)等价于reduce(operator.add, range(n), m)，要更精确地对浮点数进行累加，请使用math.fsum()。

super(type[, object-or-type])
返回一个指代type的父类或者兄弟类的对象，可以用这个对象间接地调用父类或者兄弟类的方法。在有复杂的类继承关系结构的时候，会很有用。用到的时候可以自行研究下这文章。

tuple([iterable])
返回一个tuple对象（元组），元素来自iterable。如果省略参数，将返回空的元组。

type(object)
返回object的类型，返回值本身是个“类型对象”。注意，进行类型判断建议使用isinstance()函数。

>>> type(1)
<type 'int'>
>>> type(type(1))
<type 'type'>
>>> type(1) == int  #非常不建议这样的使用方法。
True
>>> isinstance(1,int)   #建议这样使用。
True

type(name, bases, dict)
不同于上面那个一个参数的type，这个方法用于快速构造一个类，传入的3个参数将分别转化为所得到的类的__name__，__bases__和__dict__。
例如，下面这两个X是等价的：

>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

unichr(i)
返回一个单个字符的unicode串，此字符的unicode码值为i。对于Unicode，此函数也是ord()的反函数。i的范围由python解释器的编译环境决定。

unicode([object[, encoding[, errors]]])
返回一个代表object的unicode字符串。
如果给定了encoding和/或errors，将用ascii或者encoding指定的编码对object进行解码，在遇到解码错误的时候，errors的值将影响函数的下一步动作：如果errors的值是'strict'（默认值），将会抛出ValueError错误；如果errors的值是'ignore'将会忽略错误，继续解码；如果errors是'replace'，将使用U+FFFD来替换当前字符。
看个例子，我的utf8环境下：

>>> unicode('我是bones7456', encoding='utf8')
u'\u6211\u662fbones7456'
>>> print unicode('我是bones7456', encoding='utf8') #可见解码成功
我是bones7456
>>> unicode('我是bones7456') #不指定编码方式，将默认使用ascii解码，失败了。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe6 in position 0: ordinal not in range(128)
>>> unicode('我是bones7456', errors='ignore') #忽略失败，可以得到英文数字部分
u'bones7456'
>>> unicode('我是bones7456', errors='replace') #替换的话，会加上一堆？？？哈哈。
u'\ufffd\ufffd\ufffd\ufffd\ufffd\ufffdbones7456'
>>> print unicode('我是bones7456', errors='replace')
������bones7456

如果没有后面的俩参数，unicode()的行为类似于str()，只不过返回的unicode字符串而已。
如果，object对象提供了__unicode__()方法，将调用此方法来返回一个可被用户自定义的unicode串。

vars([object])
如果省略object，vars()和locals()类似，如果object是模块、类、类的对象或者其他还有__dict__属性的对象的话，就返回它的__dict__。

xrange([start], stop[, step])
此函数和range()非常类似，但是返回的不是一个列表，而是一个xrange对象。xrange对象在被引用时，也能生成列表的各项，但是这些项不是同时存在于内存里的。xrange和range比的优势是更小巧，更快。

zip([iterable, …])
哈，说到这个函数，我还给python官方文档提过一个bug，因为之前版本的文档的示例代码有点小问题，前因后果可以看这里。
zip函数返回一个元组的列表，第i个元组，就包含了每个iterable的第i项。如果参数的各iterable不一样长，会别截取到最短的值，这个值也就是结果列表的长度。
然后，zip内如果有个 * 开头，将会执行逆运算（unzip），示例：

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> zipped
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zipped)
>>> x == list(x2) and y == list(y2)
True

__import__(name[, globals[, locals[, fromlist[, level]]]])
此函数被import语句调用。代码中很少会用到这个函数，除非你要import的模块名是运行时才可知的。就不详述了。

前几天，对gentoo进行常规升级的时候，就有个别包没有编译过去，这对gentoo来说本不算什么的（谁让咱用的是 ~x86 呢），也就没太在意，但是近来越来越多的不同的包都出现了同一个错误：
报缺少 /usr/lib/libGL.la 文件，revdep-rebuild 也不能解决问题，甚至 revdep-rebuild 的过程中也有这个错误。
于是到sir里搜了一下，发现已经有人问过了，也得到了解决。
解决办法就是装上 lafilefixer ，运行一下

lafilefixer --justfixit

其实，la文件本身就是一个记录同名动态库或者静态库文件信息的一个文本文件。而lafilefixer也仅仅是一个bash脚本，它把需要更新的la文件都重写了一遍，哈哈。

从昨天下午3点半左右开始，我那ubuntu源服务器，就一直处于无法访问的状态了。
当时是机房先给我打的电话，告诉我服务器ping不通了。由于当时我离机房甚远，而且自己身体也不舒服（周末两天都在感冒发烧，好在不是H1N1，呵呵），于是只能试着让机房给重启服务器。不幸的是重启以后还是不通。
所以一直拖到今天上班了，我才有机会去机房，一大早就看了一下，服务器本身没有问题，但是网络完全不通，ping网关都不通了。
找网络部的人折腾了一个上午，终于算是恢复了。虽然对方没说具体是啥问题，但我想肯定是犯了什么低级错误了。。。
呃，虽然这问题我也无法控制，但还是要因此向大家致歉，望见谅。。。

本blog之前的几个feed地址都是WP自带生成的，比如Atom地址、RSS .92地址、RSS 2.0地址。但是无奈这几个地址虽然都能通过验证（虽然有时会超时），在其他RSS阅读器里也都显示正常，但在google reader里显示的时候，总会有这样那样的问题，给GR报告了bug也迟迟不能得到解决，无奈之下就又烧了这个 feedburner 的地址： http://feeds.feedburner.com/bones7456 如果你用的是GR，要订阅本blog的话，可以使用这个。谢谢大家。

今天，群里几个熟人，不知道怎么地，就扯到自己在各linux论坛的注册时间上了，然后看了一下，我在几个论坛的注册时间都是06年的，比大伙都晚一些，也就是说，我是从06年开始，才开始广泛使用linux的。
但是这并不代表我是那时候才接触linux的，因为我在linux公社的注册时间居然是03年11月，哈哈，这连我自己都感到非常惊讶了。
然后，我搜了一把我最早发的贴，真是感慨万千啊。那时候，还在大学的我，刚买了一个电脑（那时候电脑很贵，是父母借钱给我买的。。），就开始了我的折腾生涯，也有那么几个日夜，我用着那按流量收费的吉通网络，在网上收集资料，发帖求助。如果不是因为这个帖子，我都已经快忘记还有这些事情了。
依稀记得，那时候装过红旗、蓝点、redhat9等，还买过rh9的盘，但是由于那时的linux可用性都还不高，还有我那电脑的sis显卡支持不好（从此，我就非常痛恨sis），网上的资料也很少，自己又很菜。这段时间持续地并不长久。
后来，一直到我毕业以后，也就是06年左右，遇到了ubuntu，才算是真的开始使用linux了。对比之前和之后，可以看出linux的进步是多么地神速啊（再次感慨ing）。

最后，当然是希望linux的发展越来越快喽，比之前还要快~

早在2006年的11月，2.6.19 版本的linux内核就已经包含了ext4文件系统。到了 2.6.28 版本，这个文件系统已经正式发布了。但是我却并不急着升上去，一来是因为我的本本是工作系统，不能出差错，二来是看到国内外这里那里的报出ext4文件系统丢失数据的bug，说是要到 2.6.30 或更高版本的内核才能确保安全。
这不，前几天ubuntu也升到9.10了，内核也是2.6.31了。gentoo早就是了，于是，万事具备了，我也就开始升级ext4，哈哈。
这里有TX的升级过程，我参考了下。
首先我在gentoo里，把ubuntu的/分区升级成了ext4。
也就这3条命令：

tune2fs -O extents,uninit_bg,dir_index /dev/DEV
e2fsck -fpDC0 /dev/DEV
fsck /dev/DEV

前两个命令都是瞬间完成的，但是fsck的过程可能会持续几分钟。
见到ubuntu的/成功升级到ext4，我就信心大增了，再去ubuntu把gentoo的/分区也升级了，也非常顺利。于是，这才敢升级我最为宝贵的 /home 。
/home 分区比较大点，时间长一点，但是完全没有问题哦。
现在硬盘里已经没有ext3啦，我新编译的2.6.31-gentoo-r5内核，也已经去掉ext3的支持啦~

PS：由于上述过程需要umount分区，如果你只有一个linux系统，也可以使用liveCD等进行操作。

========20091227 update========
升级以后，可能会遇到grub菜单无法显示的问题，详情见这里。

在月光博客看到这个谷歌相关链接的内测介绍，我心想自己也算是一个谷粉了，而且blog也没有用类似的相关链接插件，于是也想试用一下，就给relatedlinks@google.com发了个邮件，没想到，今天就收到内测邀请了。
试用了一下，得益于谷歌的技术实力，相关性做得还是不错的。但是由于还在内测阶段，所以页面展示还是有蛮大的限制的。只能设置简单的背景和前景色，其他字体大小和div宽度之类的都是写死的，放在我的页面会显得很难看。不得已，我在自己的样式里，加了几个丑陋的!important才算是大致调得差不多了。
看看右边侧栏的“谷歌相关链接”吧~这就是最终的效果。

byobu的意思，是“屏风”。它提供了一系列漂亮的screen配置。所以，这个包之前叫做screen-profile。
先来看一个截图：

如图，这基本上是默认的byobu设置的效果（除了我加了一个电池电量指示的以外），可以看到，screen的底下有俩状态行，倒数第二行是每个shell的名字，右边是一个菜单的提示；最后一行从左至右依次是：byobu的logo（\o/有点像举起俩手的人哦。。）、系统版本、uptime、电池电量、load_average、CPU状态、内存状态、日期时间，如果ubuntu有更新包或者需要重启，也会有相应的提示。当然，还可以自己配置其他的，还可以加上诸如wifi状态、硬盘空间、风扇转速、hostname、IP地址，邮件提示，等等。
除了这个默认配色以外，byobu还提供多种不同的配色方案，一定能找到你喜欢的。而且，这些设置不仅能在运行前设置好，还可以在运行时实时修改，只要你打开menu（默认按F9），就可以很方便地进行设置了。
配置可以通过“byobu-config”命令来修改。使用只要用“byobu”命令代替原来的“screen”就行了。

先所说gentoo，前段时间，我一直是用的 xf86-video-radeonhd ，但是自从出了 xf86-video-radeonhd-1.3.0 以后，我就进不去X了，一进去就黑屏重启。之前mask掉这个版本，还能继续用 xf86-video-radeonhd-1.2.5 撑着，但是最近 xorg-server 也升级到了 1.7.1 了，由于一些相关的依赖包的改动，我的 xf86-video-radeonhd-1.2.5 再也编译不过去了。。。虽然 xf86-video-radeonhd-1.3.0 是能编译过去的，但是却仍然黑屏。。。无奈，在ubuntu下呆了几天，想等gentoo的包更新解决这些问题的，但是到现在也还没解决，然后我的ubuntu又想升级到9.10了，就想先把gentoo折腾好，我可不想两个linux都崩溃掉，我还要靠这俩上班的呢，呵呵。于是，回到gentoo，把全局的radeonhd改成了radeon，然后装上 x11-drivers/xf86-video-ati ，果然就正常了。而且glxgears也可以到2400多，似乎比用radeonhd时还好一些，不错，gentoo就算是搞定了。
然后，有了gentoo的保障以后，我就大胆地回ubuntu升级了，这次升级过程倒是非常顺利：有自己的源，下载时间可以忽略不计，安装用了1个多小时，也就顺利完成了。karmic的启动过程很惊艳，我很喜欢，其他的都很正常，算是一切顺利。
我喜欢我的gentoo+ubuntu的组合，爱用哪个用哪个，一个暂时折腾坏了还可以用另外一个顶，哈哈~