python_notebook

在南京苦待一个月,最后两星期看了下python,主要是diveintopython,做下笔记，以备忘.
"Python"
Line Comment = #  
Escape Char = \
File Extensions = PY PYW

/Indent Strings = ":"
/Function String 1 = "%[ ,^t]++def[ ]+^([a-zA-Z0-9_]+*^):"
/Function String 2 = "%[ ,^t]++^(class[ ]+[a-zA-Z0-9_]+*^):"
/Delimiters =   []{}()="'.,:+
1."Reserved Words"
assert
break
continue
class
def del
elif else except exec
finally for from
global
if import in is
lambda
map
not and or
None  
pass print
try raise range return
while
2."Built-in Functions"
abs apply
callable chr cmp coerce compile complex
delattr dir divmod
eval execfile
filter float
getattr globals group
hasattr hash hex
id input int intern isinstance issubclass
joinfields
len list local long
max min match
oct open ord
pow
raw_input reduce reload repr round
search setattr setdefault slice str splitfields
unichr unicode
tuple type
vars
xrange
zip
__import__
3."__Methods__"
__abs__ __add__ __and__
__call__ __cmp__ __coerce__
__del__ __delattr__ __delitem__ __delslice__ __div__ __divmod__
__float__
__getattr__ __getitem__ __getslice__
__hash__ __hex__
__iadd__ __isub__ __imod__ __idiv__ __ipow__ __iand__ __ior__ __ixor__
__ilshift__ __irshift__
__invert__ __int__ __init__
__len__ __long__ __lshift__
__mod__ __mul__
__neg__ __nonzero__
__oct__ __or__
__pos__ __pow__
__radd__ __rdiv__ __rdivmod__ __rmod__ __rpow__ __rlshift__ __rrshift__

__rshift__ __rsub__ __rmul__ __repr__
__rand__ __rxor__ __ror__
__setattr__ __setitem__ __setslice__ __str__ __sub__
__xor__
4."__Attributes__"
__bases__
__class__
__dict__ __doc__
__methods__ __members__
__name__
__version__
5."Exceptions"
ArithmeticError AssertionError
EOFError Exception
FloatingPointError
IOError ImportError IndentationError IndexError
KeyboardInterrupt
LookupError
MemoryError
AttributeError
NameError
OverflowError
RuntimeError
StandardError SyntaxError SystemError SystemExit
TabError TypeError
KeyError ValueError
ZeroDivisionError
6."Operators"
+=  
-=  
%=  
/=  
**=  
&=  
|=  
^=  
>=  

   
         
   
短标志和长标志的顺序必须是相同的，你应该先指定有长标志的短标志，然后才是剩下的短标志
================================DiveIntoPython用到的模块======================================
os
sys
re
StringIO
string
httplib
htmllib
sgmllib
urllib
urllib2
xml
copy
glob
timeit
time
unittest
__future__ (from __future__ import nested_scopes)
===============================DiveIntoPython_Note=========================================================
什么时候你应该使用 from module import？
    * 如果你要经常访问模块的属性和方法，且不想一遍又一遍地敲入模块名，使用 from module import。
    * 如果你想要有选择地导入某些属性和方法，而不想要其它的，使用 from module import。
    * 如果模块包含的属性和方法与你的某个模块同名，你必须使用 import module 来避免名字冲突。
__init__ 在类的实例创建后被立即调用。可以看作是构造函数,但是是不同的
每个类只能有一个 __init__ 方法，并且如果一个子类拥有一个 __init__ 方法，它总是覆盖父类的 __init__ 方法，甚至子类可以用不同的参数列表来定义它
当在你的类中调用父类的一个方法时，你必须包括 self 参数。
__init__ 方法是可选的;但是一旦你定义了，就必须记得显示调用父类的 __init__ 方法（如果它定义了的话）。
__init__方法从不返回一个值。
数据属性，类属性类的静态数据，类实例的数据
类属性既可以通过直接对类的引用，也可以通过对类的任意实例的引用来使用
在Python中，所有的专用方法(在特殊情况下或当使用特别语法时由 Python 替你调用的，而不是在代码中直接调用（象普通的方法那样)如 __setitem__）和内置属性（象 __doc__）遵守一个标准的命名习惯：开始和结束都有两个下划下。
一个 Python 函数，方法，或属性是私有还是公有，完全取决于它的名字。它的名字以两个下划线开始（但不是结束），它是私有的；其它所有的都是公有的。
Python 没有类方法保护的概念（只能用于它们自已的类和子类中）。类方法或者是私有（只能在它们自已的类中使用）或者是公有（任何地方都可使用）。
一个松散正则表达式和一个紧凑正则表达式主要区别表现在两个方面：
* 忽略空白符。空格符，制表符，回车符不匹配它们自身，他们根本不参与匹配。(如果你想在松散正则表达式中匹配一个空格符，你必须在它前面添加一个反斜线符号对他进行转义)
* 忽略注释。在松散正则表达式中的注释和在普通Python代码中的一样：开始于一个#符号，结束于行尾。这种情况下，采用在一个多行字符串中注释，而不是在源代码中注释，他们以相同的方式工作。
>>> pattern = """
    ^                   # beginning of string
    M{0,4}              # thousands - 0 to 4 M's
    (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
                        #            or 500-800 (D, followed by 0 to 3 C's)
    (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
                        #        or 50-80 (L, followed by 0 to 3 X's)
    (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
                        #        or 5-8 (V, followed by 0 to 3 I's)
    $                   # end of string
    """
>>> re.search(pattern, 'M', re.VERBOSE)     
???"自省"是指代码可以查看内存中以对象形式存在的其它模块和函数，获取它们的信息，并对它们进行操作。
用这种方法, 你可以定义没有名称的函数，不按函数声明的参数顺序调用函数，甚至引用事先并不知道名称的函数。
"重构"是在可运行代码的基础上使之更良好工作的过程。
通常，“更好”意味着“更快”，也可能意味着 “使用更少的内存”，或者 “使用更少的磁盘空间”，或者仅仅是“更优雅的代码”。
* 如果你要在正则表达式和编写循环间抉择，选择正则表达式。
* 如果你需要在正则表达式和字符串方法间抉择，选择字符串方法。     
* 字典查找的通常应用很快，但是 string.maketrans 之类的特殊函数和 isalpha() 之类的字符串方法更快。
* 别太聪明了。 有时一些明显的算法是最快的。
* 不要太迷恋性能优化，性能并不是一切。
type      返回任意对象的数据类型
str       将数据强制转型为字符串。每种数据类型都可以强制转型为字符串。
dir       返回对象的属性和方法列表
callable 确定一个对象的属性是否是可调用的
getattr  获取对象引用(常见的使用模式是作为一个分发者,应用于模块;getattr能够使用可选的第三个参数，一个缺省返回值。)
hasattr  判断一个对象是否有某个属性
sys.modules 返回模块的引用
locals() globals()
type、str、dir和其它的Python内置函数都归组到了 __builtin__这个特殊的模块中。你可以认为 Python 在启动时自动执行了 from __builtin__ import *，此语句将所有的 “内置” 函数导入该命名空间，所以在这个命名空间中可以直接使用这些内置函数。
任何可调用的对象都有 doc string
严格地讲, 在小括号, 方括号或大括号中的表达式 (如 定义一个 dictionary) 可以用或者不用续行符 (“\”) 分割成多行。甚至在不是必需的时候, 我也喜欢使用续行符, 因为我认为这样会让代码读起来更容易, 但那只是风格的问题。
>>>params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>>["%s=%s" % (k, v) for k, v in params.items()]
>>>"%(pwd)s" % params
映射列表语法 :
[mapping-expression for element in source-list]
过滤列表语法：
[mapping-expression for element in source-list if filter-expression]
import re
re.sub()
re.search()
re.compile() *返回编译后的对象
import String
import os
os.listdir()
os.path.getcwd()
os.path.normcase()
os.path.join()
os.path.split()
os.path.splittext()
os.path.isfile()
os.path.isdir()
import glob
glob.glob('c:\\music\\_singles\\*.mp3')      
list2=filter(function1,list1)
list2=map(funciton1,list1)
内建 __import__函数与import语句的既定目标相同，但它是一个真正的函数，并接受一个字符串参数。
当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。这种方法在函数需要获取可变数量的参数的时候特别有用。
functionname(power,*arg):多余参数作为元组
functionname(power,**arg):多余参数作为字典
lambda函数:
生成器:yield
>>>def make_counter(x):
...     print 'entering make_counter'
...     while 1:
...         yield x               1
...         print 'incrementing x'
...         x = x + 1
for line in file(...)是从文件中一行行读取的通用方法，每次一行。它能正常工作是因为 file 实际上返回一个生成器，它的 next() 方法返回文件中的下一行。
pattern, search, replace = line.split()等价于(pattern, search, replace) = line.split()  
异常处理:
try...except...else
循环语句也还可以带一个 else 子句，当循环正常结束时执行其内容，但如果循环是用break 语句跳出的则不执行其内容。
最后一个except子句可以省略例外名，作为一个通配项。这种方法要谨慎使用，因为这可能会导致程序实际已出错却发现不了。
try...finally
假如读一个文件的时候，希望在无论异常发生与否的情况下都关闭文件，该怎么做呢？这可以使用finally块来完成。注意，在一个try块下，你可以同时使用except从句和finally块。如果你要同时使用它们的话，需要把一个嵌入另外一个。
try语句有了except子句就不能有finally子句，有了finally子句就不能有except 子句，不能同时使用except子句和finally子句。需要的话可以嵌套。
raise ExceptionName, args:
raise一般可嵌在try里使用
可以定义自己的例外，只要把一个字符串赋给一个变量即可。例如：
>>> my_exc = 'my_exc'
>>> try:
...     raise my_exc, 2*2
... except my_exc, val:
...     print 'My exception occurred, value:', val
...
My exception occurred, value: 4
>>> raise my_exc, 1
Traceback (innermost last):
  File "", line 1
my_exc: 1
用户自定义的例外除了可以是字符串对象以外还可以是类。这样可以定义可扩充的分层的类例外结构。
raise语句有两种新的有效格式：
raise 类, 实例
raise 实例
在第一种形式中，“实例”必须是“类”的实例或“类”的导出类的实例。第二种形式是
raise instance.__class__, instance
的简写。except语句除了可以列出字符串对象外也可以列出类。
许多标准模块用这种方法报告自己定义的函数中发生的错误。　
    * 使用不存在的字典关键字 将引发 KeyError 异常。
    * 搜索列表中不存在的值 将引发 ValueError 异常。
    * 调用不存在的方法 将引发 AttributeError 异常。
    * 引用不存在的变量 将引发 NameError 异常。
    * 未强制转换就混用数据类型 将引发 TypeError 异常。
list
     append()
     insert(sitenum,item)
     extend([])
     remove()
     sort()
     reverse()
     count()
     pop()
     index()
     in
     del
“reduce(函数, 序列)”用来进行类似累加这样的操作，这里的函数是一个两个子变量的函数，reduce()先对序列的前两项调用函数得到一个结果，然后对结果和序列下一项调用函数得到一个新结果，如此进行到序列尾部。
list运算符
+
+=
*
dict：
d.has_key()
d.keys()
d.values()
d.items()
del d[]
d.clear()
Tuple 是不可变 list,一旦创建了一个 tuple 就不能以任何方式改变它。元组没有方法!!
使用 in 来查看一个元素是否存在于 tuple 中
tuple 比 list 操作速度快。
文件对象:
f=open('filename path',mode)
   f.read()
   f.readline()
   f.readlines()
   f.seek()
   f.tell()
   f.write()
   f.close()
   isatty()和truncate()
缺省值只计算一次。当缺省值是可变对象如列表或字典时这一点是要注意的。例如，以下函数会在以后的调用中累加它的值：
def f(a, l = []):
    l.append(a)
    return l
print f(1)
print f(2)
print f(3)
This will print
　
[1]
[1, 2]
[1, 2, 3]
如果你不希望缺省值在连续的调用中被保留，可以象下面这样改写函数：
def f(a, l = None):
    if l is None:
        l = []
    l.append(a)
    return l
优先级：
逻辑运算符(or<and<not)<比较运算符<数值运算符
输出的三种形式:表达式语句,print,文件对象的write()方法
输出格式:+连接的自定义,string的rjust(),ljust()方法,%
repr与``可将值转化为字符串
pickle cpickle模块
几乎任何Python对象转换为字符串表示，这个过程叫做腌制，从对象的字符串表示恢复对象叫做恢复
如果你有一个对象x，有一个可写的文件对象f，腌制对象的办法是：
pickle.dump(x, f)
为了恢复对象，如果刚才的文件已打开用于读取，文件对象名仍为f，则：
x = pickle.load(f)
在任何运行时刻，总是恰好有三个作用域在使用中（即恰好有三个名字空间是直接可访问的）：最内层的作用域，最先被搜索，包含局部名字；中层的作用域，其次被搜索，包含当前模块的全局名字；最外层的作用域最后被搜索，包含内置名字。
赋值总是进入最内层作用域。关于删除也是这样：“del x”从局部作用域对应的名字空间中删除x的名字绑定
类:
类对象   :属性引用(数据属性,函数对象) 实例化
实例对象 :属性引用(*数据属性*(不需要声明，也不需要在类定义中预先存在，象局部变量一样，只要一赋值它就产生了),方法对象)
有时我们希望有一种类似C的“struct”的类型，可以把几个有名的数据项组合在一起。一个空类可以很好地满足这个需要