作者写得很容易让人明白，真是好书。 Python创建一个对象时，比如PyIntObject,会分配内存，进行初始化。然后用一个PyObject *变量，而不是通过PyIntObject* 变量来保存和维护这个对象。在python内部各个函数直接传递的都是泛型指针 PyObject *。指针所指的对象是什么类型的我们不知道，只能从指针所指的对象的ob_type域动态判断（PyTypeObject），python正是通过这个域实现了多态   书上举了Print的例子 void Print(PyObject * object){ object -> ob_type -> tp_print(object) } 如果传给Print的指针是一个PyIntObject *,从PyObject指针找到ob_type指针再调用类型里对应的输出操作。作者在前面对这几个关键对象做了讲解，这里很好理解。     对象池   数值比较小的整数在程序中会频繁使用，为解决频繁内存申请和释放，使用对象池。对象池里的每一个PyInetObject对象都能够被任意的共享。大整数和小整数的分界点默认设定为[-5,257)，修改方式，修改源码重新编译python。 对于大整数对象，python提供一块内存空间，由大整数轮流使用。数量为82个，也可以通过修改源码改变。 PyIntObject创建的过程，如果是小整数对象，则返回在小整数对象池中的对应的对象。如果不是，使用通用整数对象池     可以很容易的理解一些问题： >>> a1=[1,2,3] >>> b1=a1 >>> b1 == a1 True >>> b1 is a1 True >>> b2 = [1,2,3] >>> a1 == b2 True >>> a1 is b2 False >>> c1=1 >>> c2 = c1 >>> c1 == c2 True >>> c1 is c2 True >>> c3 =1 >>> c3 == c1 True >>> c3 is c1 True   ==判定具有相同的值，is判定是同一个对象。A1 b1是对同一个列表的引用，is返回True，a1 b2不是，返回False。下面的c3 c1 返回True，是对同一对象的引用。  

在编写chrome扩展的时候，遇到“即将停止支持清单版本 1。请升级到版本 2。”的警告。 解决方法： 在manifest.json文件中增加：

{
  ...,
  "manifest_version": 2,
  ...
}
官方文档：http://developer.chrome.com/extensions/manifestVersion.html

几个比较常用的，翻译了一点官方文档。文档http://docs.python.org/2/library/functions.html#built-in-functions startswith，endswith str.endswith(suffix[, start[, end]]) str.startswith(prefix[, start[, end]]) >>> s="python" >>> s.startswith('py') True >>> s.startswith('th',2) True >>> s.startswith(('py','yt')) True >>> s.startswith(('py','yt'),1) True 判断字符串是否以suffix结尾，以prefix开始，是，返回true。stat，end是截取字符串。从python2.5开始，支持元祖。 lambda 匿名函数 >>> f = lambda x:x+1 >>> f(2) 3 >>> (lambda x,y:x*y)(2,3) 6 内建函数开始： zip([iterable, ...]) 返回一个元组列表，由每个参数队列的第i个元素组成元祖。列表的长度是参数队列里面最短的一个的长度。一个参数返回一个一元元组？？的列表，无参数返回空列表。zip(*[iter(s)]*n)是个逆操作？ >>> a=[1,2,3] >>> b=[4,5,6] >>> c=[4,5,6,7,8,9] >>> zip(a,b) [(1, 4), (2, 5), (3, 6)] >>> zip(a,c) [(1, 4), (2, 5), (3, 6)] >>> zip(a) [(1,), (2,), (3,)] >>> zip() [] >>> zip(*[(1, 4), (2, 5), (3, 6)]) [(1, 2, 3), (4, 5, 6)] >>> x,y = zip(*[(1, 4), (2, 5), (3, 6)]) >>> print x,y (1, 2, 3) (4, 5, 6) filter(function, iterable) 返回一个列表，由iterable里元素能使function返回真的元素构成。当iterable是元组或者字符串时，返回类型不变，其他返回list。如果function为None，将假定一个function，iterable的元素都符合（文档咋没看懂，感觉正好相反）。 filter(function, iterable)等价[item for item in iterable if function(item)]，这个肯定是列表啊，不一定等价 function为None，等价[item for item in iterable if item]。 >>> filter(lambda x:x>2,[1,2,3,4]) [3, 4] >>> filter(None,[1,2,3,4]) [1, 2, 3, 4] >>> filter(lambda x:x>'c',"abcdef") 'def'   map(function, iterable, ...) 将每一个iterable的元素带入function，组成列表返回。 >>> map(lambda x:x+2,[1,2,3,4]) [3, 4, 5, 6] reduce(function, iterable[, initializer]) 从左到右依次取iterable中的元素，带入function。initializer是初始值，function有两个参数，有初始值第一个参数为初始值，第二个从iterable中取，然后执行function，结果带入第一个参数，第二个参数取iterable下一个元素。 >>> a=[1,2,3,4] >>> reduce(lambda x,y: x+y,a) 10 >>> reduce(lambda x,y: x+y,a,10) 20

以前看过一部分了，现在拿起来重新看。不准备像作者一样一步一步的修改代码测试验证，我只是懂得机理，知道是个什么东西就行，作者叙述的内容已经经过验证不会有什么错误。代码我也是下载的python2.5版本的，对照着看看。   Python中，对象就是c中的结构体在堆上申请的一块内存，一般的，对象是不能被静态初始化的，并且也不能再栈空间上生存。唯一例外就是类型对象，内建类型对象（整数类型对象，字符串类型对象）都是静态初始化的。   PyObject  

typedef struct _object {

Py_ssize_t ob_refcnt;

struct _typeobject *ob_type

} PyObject

typedef struct {

PyObject_HEAD

long ob_ival;

} PyIntObject

#define PyObject_VAR_HEAD             \

PyObject_HEAD                  \

Py_ssize_t ob_size; /* Number of items in variable part */

typedef struct {

PyObject_VAR_HEAD

} PyVarObject

typedef struct _typeobject {

PyObject_VAR_HEAD

const char *tp_name; /* For printing, in format "<module>.<name>" */

Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */

struct _typeobject *tp_base;

…

} PyTypeObject

总结的很好，《golang web 编程》作者维护的golang博客：http://beego.me/ 。。。。。。。。。。。。。。。。 我们在写Go代码的时候经常用到import这个命令用来导入包文件，而我们经常看到的方式参考如下：

import(
    "fmt"
)

fmt.Println("hello world")

import(
    . "fmt"
)

import(
    f "fmt"
)

import (
    "database/sql"
    _ "github.com/ziutek/mymysql/godrv"
)

1.数组，Array make-array 构造一个数组。 [9]> (make-array '(2 3)) #2A((NIL NIL NIL) (NIL NIL NIL)) [10]> (make-array '(3 3)) #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL)) 其中 n 是数组的维度。 [11]> #2a((1 2 3) (4 4 4)) #2A((1 2 3) (4 4 4)) 可以使用:initial-element 参数初始化数组元素的值。 [12]> (make-array '(2 3) :initial-element 2) #2A((2 2 2) (2 2 2)) 取出数组内的元素我们调用 aref，要替换数组的某个元素，我们使用 setf 和 aref。 > (setf arr (make-array '(2 3))) #2A((NIL NIL NIL) (NIL NIL NIL)) > (aref arr 0 1) NIL > (setf (aref arr 0 1) 'b) B > (aref arr 0 1) B > arr #2A((NIL B NIL) (NIL NIL NIL)) 2.字符串 一个字符 c 用 #\c 表示 字符比较函数 char< (小于)， char<= (小于等于)， char= (等于)， char>= (大于等于) ， char> (大于)，以及 char/= (不同) aref 来取出元素，但对一个字串，你可以使用更快的 char 函数。 [30]> (aref "abc" 1) #\b [31]> (char "abc" 1) #\b 比较两个字串，你可以使用通用的 equal 函数，但还有一个忽略大小写的比较函数 string-equal。 连接字符串 [7]> (concatenate 'string "not " "to worry") "not to worry" 3.结构 定义结构使用 defstruct， [8]> (defstruct point x y) POINT 定义了一个 point 具有两个字段 x 与 y，操作方法： [9]> (setf p (make-point :x 0 :y 0)) #S(POINT :X 0 :Y 0) [10]> (point-x p) 0 [11]> (point-y p) 0 [12]> (setf (point-y p) 2) 2 [13]> p #S(POINT :X 0 :Y 2) 测试是否是一个point： [14]> (point-p p) T make-point , point-p , copy-point , point-x 及 point-y 函数都是在定义结构时隐式定义了。 4.哈希表 (Hash Table) 当列表的长度大幅上升时（或是 10 个元素），使用哈希表会来得比较快。 [1]> (setf ht (make-hash-table)) #S(HASH-TABLE :TEST FASTHASH-EQL) [2]> (gethash 'color ht) NIL ; NIL [3]> (setf (gethash 'color ht) 'red) RED [4]> (gethash 'color ht) RED ; T [5]> ht #S(HASH-TABLE :TEST FASTHASH-EQL (COLOR . RED)) [6]> (setf (gethash 'size ht) '10) 10 [7]> ht #S(HASH-TABLE :TEST FASTHASH-EQL (SIZE . 10) (COLOR . RED)) [12]> (remhash 'size ht) NIL [13]> ht #S(HASH-TABLE :TEST FASTHASH-EQL (COLOR . RED)) make-hash-table构造一个哈希表，gethash第一个参数是键值，第二个是哈希表。返回的第一个参数是键值对应的值，不存在返回nil。第二个参数表示是否存在对应的值，不存在为nil，应该主要为了区别方便判断，比如nil可能为值。remhash是删除一个记录。 [14]> (setf ht2 (make-hash-table :size 5)) #S(HASH-TABLE :TEST FASTHASH-EQL) [15]> (setf ht3 (make-hash-table :test #'equal)) #S(HASH-TABLE :TEST FASTHASH-EQUAL) 参数:size指定哈希表的大小，:test指定查询时候比较时用的函数，从构造完返回的值有显示:test的不同。 common lisp函数还真不是一般的多，从第一次看就感觉有很多函数没必要有，现在的感觉是无论用其他的能不能实现，只要你想到的就必须用一个函数可以直接实现。感觉好怪

python中的and-or可以用来当作c用的？：用法。比如 1 and a or b，但是需要确保a为True，否则a为False，还要继续判断b的值，最后打印b的值。 今天看到一个好方法避免这种情况，记录一下： (1 and [a] or [b])[0] 可以保证[a]为True。

1.映射函数 [1]> (setf l '(1 2 3)) (1 2 3) [8]> (mapcar #'(lambda (x) (+ x 10)) l) (11 12 13) maplist 接受同样的参数，将列表的渐进的下一个 cdr 传入函数 [9]> (maplist #'(lambda (x) x) l) ((1 2 3) (2 3) (3)) 2.树 看完这一节，才对lisp的其中一个优点有所理解。就像lisp的名字“Lisp” 起初是 “LISt Processor” 的缩写。都是列表啊。 Cons 对象可以想成是二元树， car 代表右子树，而 cdr 代表左子树。图就不传了，原图有点错误，这个比较好理解。 我们有下面的列表。 [13]> (setf x 1) 1 [15]> (and (integerp x) (zerop (mod x 2))) NIL [16]> (setf x 2) 2 [17]> (and (integerp x) (zerop (mod x 2))) T [18]> (setf x 2.0) 2.0 [19]> (and (integerp x) (zerop (mod x 2))) NIL 用来判断x是整数，并且被2 整除，这不是函数形式，想把其中的x改成y的时候。我们将他看成整个列表进行操作。看到这里我才明白，汗。 [20]> (subst 'y 'x '(and (integerp x) (zerop (mod x 2)))) (AND (INTEGERP Y) (ZEROP (MOD Y 2))) 单引号的功能前边有介绍，但是没这样的例子，当时还是仅仅的理解为'(a b c)。 [24]> (cons 'a 'b) (A . B) 这是一个非正规列表，称之为 [caption id="attachment_808" align="alignnone" width="96" caption="点状列表"][/caption] 。 common lisp列表操作的函数好多，大概试了，就不记录了，等以后查看文档。

1.列表(Lists) cons把两个对象结合成一个有两部分的对象，称之为 Cons 对象。概念上来说，一个 Cons 是一对指针; 第一个是 car ，第二个是 cdr 。 任何非空的列表，都可以被视为一对由列表第一个元素及列表其余元素所组成的列表。 [1]> (setf x (list 'a 'b 'c)) (A B C) [2]> (car x) A [3]> (cdr x) (B C) 看图理解cons。 [caption id="attachment_801" align="alignnone" width="298" caption="lisp list"][/caption] 可以这么些： [8]> (setf y (cons 'a (cons 'b (cons 'c nil)))) (A B C) 与图中所画内容相对应了 嵌套列表 [9]> (setf z (list 'a (list 'b 'c) 'd)) (A (B C) D) [10]> (car (cdr z)) (B C) [caption id="attachment_802" align="alignnone" width="300" caption="lisp嵌套列表"][/caption] 如果参数是一个 Cons 对象，函数 consp 返回真。

(defun our-atom (x) (not (consp x)))

1.变量 let引入新的局部变量。 [33]> (let ((x 1) (y 2)) (+ x y)) 3 defparameter创造一个全域变量。 [37]> (defparameter *ga* 123) *GA* [38]> *ga* 123 用 defconstant 来定义一个全域的常量 [39]> (defconstant limit 8 ) LIMIT [40]> limit 8 检查某些符号，是否是一个全域变量或常数，用 boundp [41]> (boundp 'limit) T [42]> (boundp '*ga*) T 2.赋值 setf给全域或局域变量做赋值，如果 setf 的第一个参数是一个符号(symbol)，且这个符号不是某个局部变量的名字，那么 setf 将设置这个符号为全局变量。还是使用 defparameter 显式地创建全局变量比较好。 [44]> *ga* 1 [45]> (let ((n 10)) (setf n 2) n) 2 [46]> (setf x (list 'a 'b 'c)) (A B C) 传入 setf 的第一个参数，还可以是一个表达式或一个变量名。在这种情况下，第二个参数的值被插入至第一个参数所引用 (refer)的地方。 [47]> (setf (car x) 'n) N [48]> x (N B C) [53]> (setf a 1 b 2 c 3) 3 [54]> a 1 [55]> b 2 [56]> c 3 相当于

(setf a b)
(setf c d)
(setf e f)

3. 类型
在 Common Lisp 里，数值才有类型，而不是变量。typep判断类型。
[57]> (typep 25 'integer)
T