最近通读了《Python核心编程》一书，记录读书笔记，重新温习下。
利用raw_input获取用户输入
user = raw_input(‘enter login name’) #接受用户输入字符串
简单for语句，迭代对象
for item in [‘a’,’b’,’c’,’d’]:
print item
for num in range(10):
print num
foo = ‘abc’
for char in foo:
print char
for i,c in enumerate(foo):
print i,c
list = [x**2 for x in range(8) if not x%2]
for i in list:
print i
try 和 except 语句
try语句子句形式表
except: 捕获所有异常
except name: 只捕获特定的异常
except name,value: 捕获异常和它的附加数据（将异常的信息保存到value，）
except (name1,name2): 捕获任何列出的异常
else: 如果没有异常
finally: 总是执行
捕获所有异常并打印
try:
pass
except Exception,ex:
print Exception,”:”,ex
多元赋值，少写 = 号和函数多返回值
x, y, z = 1, 2, ‘a string’
x #1
y #2
z #’a string’
#函数多返回值
def a():
return 1,2
(x,y) = a()
x #1
y #2
is判断两个变量是否内存地址相同
a = ‘1’
b = ‘1’
c = [‘1’]
d = c
print a is b #false
print c is d #true
isinstance 判断类型是否是基类的实例
num = 1
print isinstance(num, int)
del 手动删除数字对象
num = 1
del num
str() 数字型转字符串
num = 1
str(num)
类型转换工厂函数 int() long() float() complex() bool()
进制转换 hex() oct() chr()
切片操作符 []
s = ‘abcdefgh’
s[::-1] #翻转字符串
s[::2] #一隔一取字符串
s[:3] # 和 s[0:3] 等价 返回abc，包含起始0，不包含末尾3
字符串，列表，元祖都是可序列类型，工厂函数
list() str() unicode() tuple()
字符串，列表，元祖都是可序列类型，具有如下内建函数：
enumerate len max min reversed sorted sum zip
字符串操作 in 和 not in
‘bc’ in ‘abcd’
‘bc’ not in ‘abcd’
定义unicode字符串
a = u’abc’
三引号字符串，保留内建空格和换行
内建函数 decode() encode() 方法，用来解码和编码字符串
数组list有 如下方法
list.insert (index, obj) #在索引index处，插入内容
list.append(obj) #在list尾部插入内容
list.count(obj) #计算这个对象在list中出现的次数
list.extend(seq) #把序列seq的内容添加的list中
list.index(obj,i=0,j=len(list)) #返回列表中值等于obj的 索引，没找到会引发异常
list.pop(index=-1) #出列指定索引值
list.remove(obj) #从列表中删除某个值
list.reverse() #翻转列表
list.sorted(func=None, key=None, reverse=False) #重新排序列表
单元素元祖
(‘xyz’,)
copy.deepcopy进行深度拷贝列表
import copy
listb = copy.deepcopy(lista) #将不会引用，深度拷贝其值
通过 fromkeys 创建字典
ddict = {}.fromkeys((‘x’, ‘y’), -1) #{‘y’: -1, ‘x’: -1}
遍历字典中的 key 和 value
dict2 = {‘name’: ‘earth’, ‘port’: 80}
for key in dict2.keys():
print ‘key=%s, value=%s’ % (key, dict2[key])
判断字典中是否含有指定的 key
‘server’ in dict2
dict2.has_key(‘server’)
删除字典元素和字典
del dict2[‘name’] # 删除键为“name”的条目
dict2.clear() # 删除 dict2 中所有的条目
del dict2 # 删除整个 dict2 字典
dict2.pop(‘name’) # 删除并返回键为“name”的条目
字典拷贝copy
dict9 = dict8.copy()
字典 len 的内建函数，返回字典中所有 键值 对的数量
dict2 = {‘name’: ‘earth’, ‘port’: 80}
len(dict2)
三元操作符
smaller = x if x < y else y
range语法
range(start, end, step=1)
简单的lambda和列表解析，下面2者是等价的
map(lambda x: x 2, range(6))
[0, 1, 4, 9, 16, 25]
[x 2 for x in range(6)]
[0, 1, 4, 9, 16, 25]
打开文件
fp = open(‘/etc/motd’) # 以读方式打开
fp = open(‘test’, ‘w’) # 以写方式打开
fp = open(‘data’, ‘r+’) # 以读写方式打开
fp = open(r’c:\io.sys’, ‘rb’) # 以二进制读模式打开
逐行读取文件
filename = raw_input(‘Enter file name: ‘)
f = open(filename, ‘r’)
for eachLine in f:
print eachLine, f.close()
with语句读取文件
with open(‘/etc/passwd’, ‘r’) as f:
for eachLine in f:
# ...do stuff with eachLine or f...
raise 触发异常
raise exclass 触发一个异常,从 exclass 生成一个实例(不含任何异常参数)
raise exclass()同上,除了现在不是类;通过函数调用操作符(function calloperator: “()”)作用于类名生成一个新的 exclass 实例,同样也没有异常参数
raise exclass, args 同上,但同时提供的异常参数 args,可以是一个参数也可以元组
raise exclass(args) 同上
raise exclass,args, tb 同上,但提供一个追踪(traceback)对象 tb 供使用
raise exclass,instance 通过实例触发异常(通常是 exclass 的实例);如果实例是 exclass的子类实例,那么这个新异常的类型会是子类的类型(而不是exclass);如果实例既不是 exclass 的实例也不是 exclass 子类的实例,那么会复制此实例为异常参数去生成一个新的 exclass 实例.
raise instance通过实例触发异常:异常类型是实例的类型;等价于raise
instance.class, instance (同上).
raise string (过时的) 触发字符串异常
raise string, args 同上,但触发伴随着 args
raise string, args, tb 同上,但提供了一个追踪(traceback)对象 tb 供使用
raise (1.5 新增)重新触发前一个异常,如果之前没有异常,触发 TypeError.
assert 断言
assert 1 == 1
assert 2 + 2 == 2 * 2
assert len([‘my list’, 12]) < 10
assert range(3) == [0, 1, 2]
函数参数定义
func(positional_args, keyword_args, *tuple_grp_nonkw_args, **dict_grp_kw_args)
函数描述符
@deco2
@deco1
def func(arg1, arg2, …): pass
#这和创建一个组合函数是等价的。
def func(arg1, arg2, …): pass
func = deco2(deco1(func))
默认参数
def func(posargs, defarg1=dval1, defarg2=dval2,…):
pass
可变参数：
形式参数必须先于非正式的参数之前出现
def tupleVarArgs(arg1, arg2=’defaultB’, theRest):
pass
关键字和非关键字可变长参数都有可能用在同一个函数中
def newfoo(arg1, arg2, nkw, kw):
pass
newfoo(‘wolf’, 3, ‘projects’, freud=90, gamble=96)
newfoo(1, 2, 3, x=4, y=5, *aTuple, aDict)
set类型
set类型来分割字符串和排序
x = set(‘spam’)
y = set([‘h’,’a’,’m’])
x, y
(set([‘a’, ‘p’, ‘s’, ‘m’]), set([‘a’, ‘h’, ‘m’]))
set类型可以用来去除重复，比如：
a = [11,22,33,44,11,22]
b = set(a)
b
set([33, 11, 44, 22])
pass语句
pass语句表示空语句，比如：
def foo_func():
pass
while - else 语句
while else语句表示当while条件为false时，执行else语句，但是break会跳过else语句
同样 for 语句也可以有else语句，情况和while相同，不是通过break执行完成的循环都会执行else语句
os模块的跨平台有用属性
os.linesep #文件中分割行的字符串
os.sep #分割文件路径名的字符串
os.pathsep #分割文件路径的字符串
os.curdir #当前工作目录的字符串名称
os.pardir #当前工作目录的父目录字符串
函数和默认参数示例
def net_conn(host, port=80, stype=’tcp’):
pass
下面都是对net_conn的有效调用：
net_conn(‘phaze’, 8000, ‘udp’) #没有使用默认参数值
net_conn(‘kappa’) #使用两个默认参数值
net_conn(‘chino’, stype=’udp’) #使用por默认值
net_conn(stype=’udp’, host=’solo’) #使用port默认值
net_conn(‘deli’, 8000) #使用stype默认值
net_conn(port=8000, host=’solo’) #使用stype默认值
闭包示例
def counter(start_at=0):
count = [start_at]
def incr():
count[0] += 1
return count[0]
return incr
count = counter(5)
print count() #6
print count() #7
namespace 命名空间
可以定义一个函数作为命名空间
def foo():
pass
foo.doc = ‘oops, fotget doc’
foo.version = 0.2
也可以定义一个类作为命名空间
class MyNameSpace(object):
pass
myns = MyNameSpace()
myns.x = 1
myns.y = 200
导入import 和 加载 load
一个模块就算被导入N次，但是只会被加载执行一次
reload函数可以重新导入和执行模块
例如：
reload(sys) #而不是reload(‘sys’)
类的静态属性
class C(object):
a=100
C.b=100
c1 = c()
C.a = 200
C.b = 300
print c1.a, c1.b
#200 300
函数修饰符
Class C:
@staticmethod
def foo():
pass
@classmethod
def foo2():
pass
继承需要手动调用基类的init方法
Class P(object):
def init(self):
pass
Class P2(P):
def init(self):
P.init(self)
pass
另外一个可以使用super内建函数来调用基类init
Class P2(P):
def init(self):
super(P2, self).init()
pass
多重继承
Class P(object):
pass
Class Q(object):
pass
Class P2(P, Q):
pass
hasattr(), getattr(), setattr(), delattr()
hasattr(), 返回布尔值，是否包含这个属性
getattr(), 获取这个属性，如果不存在，则会抛异常，除非个他设定默认值，不会抛异常
setattr(), 设定属性值
delattr(), 删除属性值
为特殊方法定制类
init(self, args) 构造器
del(self) 析构器
str(self) str()和print()类实例时实现
repr(self) repr()实现
unicode(self) unicode()实现
call(self, args) 表示实例可调用
nonzero(self) bool()实现
len len()实现
lt(self,obj), le(self,obj) <, <=实现
gt(self,obj), ge(self,obj) >, >=实现
eq(self,obj), ne(self,obj) ==, !=实现
等等。。。
私有方法：
在类属性命名时加上单下划线’_private’
slots类属性
可以限制实例的属性数量，比如代码：
Class P(object):
slots = (‘foot’, ‘bar’)
c = P()
c.foo = 42
c.xxx = ‘50’
#这里将抛异常
@property描述符
通过property描述符可以用来隐藏类属性，见代码：
class C(object):
def init(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
print 'get'
return self._x
@x.setter
def x(self, value):
print 'set'
self._x = value
@x.deleter
def x(self):
print 'del'
del self._x
d = C()
d.x = 1
d.x
del d.x