一句话搞定一件事¶
Python 2 or Python 3 ?¶
后续讲解基于 Python 2.7 ...
Python编码¶
转码思路¶
字符串在Python内部的表示是unicode编码，在编码转换时通常需要以unicode作为中间编码。
先将其他编码的字符串解码(decode)成unicode，再从unicode编码(encode)成另一种编码。
转码举例¶
s.decode(‘utf-8’, ‘ignore’).encode(‘gbk’, ‘ignore’)
先由utf-8转为unicode，再由unicode转为gbk，ignore表示忽略非法字符intersection
s = u'中文' # s为unicode
print isinstance(s, unicode) # True
print s.encode('utf-8', 'ignore') # 中文
# 由unicode转为utf-8，ignore表示忽略非法字符
异常处理¶
try-except-finall结构¶
import traceback
try:
xxx
except Exception, e:
print e
print traceback.format_exc()
raise
finally:
print 'end'
记录错误¶
import logging
except StandardError, e:
logging.exception(e)
字符串¶
不可变类型¶
>>> a = 'abc'
>>> a
'abc'
>>> b = a.replace('a', 'A')
>>> a
'abc'
>>> b
'Abc'
带关键字与不带关键字的格式化¶
>>> 'Hello %(name)s !' % {'name': 'James'}
'Hello James !'
>>> 'Hello %s !' % 'James'
'Hello James !'
>>> 'Hello {name} !'.format(name='James')
'Hello James !'
>>> 'Hello {} !'.format('James')
'Hello James !'
列表¶
列表是由一系列元素组成的有序的序列。
append与extend¶
list1.append(xxx) # 表示在list1后添加元素xxx
list1.extend(list2) # 表示在list1后添加序列list2
zip函数¶
>>> list1 = ['a', 'b']
>>> list2 = ['1', '2']
>>> zip(list1, list2)
[('a', '1'), ('b', '2')]
>>> zip(*[list1, list2])
[('a', '1'), ('b', '2')]
enumerate函数：把list变成’索引-元素’对¶
>>> word = ['c', 'b', 'd', 'a']
>>> word.sort()
>>> word
['a', 'b', 'c', 'd']
>>> for i, value in enumerate(word):
print i, value
0 a
1 b
2 c
3 d
enumerate函数实现¶
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1
列表去重¶
>>> l = [1, 2, 4, 7, 2, 1, 8, 6, 1]
>>> list(set(l)) # 不保证顺序
[1, 2, 4, 6, 7, 8]
>>> sorted(list(set(l)), reverse=True) # 顺序
[8, 7, 6, 4, 2, 1]
>>> {}.fromkeys(l).keys() # 不保证顺序
[1, 2, 4, 6, 7, 8]
>>> from collections import OrderedDict
>>> OrderedDict().fromkeys(l).keys() # 按照原有序列顺序
[1, 2, 4, 7, 8, 6]
列表推导式¶
>>> [x*x for x in range(10)] # 一层循环
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [m + n for m in 'ABC' for n in 'XYZ'] # 两层循环
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
引用、浅复制、深复制¶
>>> import copy
>>> l = [0, [1, 2], 3]
>>> l1 = l # 引用
>>> l2 = l[:] # 浅复制
>>> l3 = copy.copy(l) # 浅复制
>>> l4 = copy.deepcopy(l) # 深复制
>>> l
[0, [1, 2], 3]
>>> l1, l2, l3, l4
([0, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3])
>>> l[0] = 9
>>> l
[9, [1, 2], 3]
>>> l1, l2, l3, l4
([9, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3], [0, [1, 2], 3])
>>> l[1][1] = 9
>>> l
[9, [1, 9], 3]
>>> l1, l2, l3, l4
([9, [1, 9], 3], [0, [1, 9], 3], [0, [1, 9], 3], [0, [1, 2], 3])
is 与 ==¶
is 比较两个对象的标识(引用)
== 比较两个对象的值(内容)
>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
def fib1(max_num):
L = []
n, a, b = 0, 0, 1
while n < max_num:
L.append(b)
a, b = b, a + b
n += 1
return L
迭代器实现Fibonacci数列¶
class fib2(object):
def __init__(self, max_num):
self.max_num = max_num
self.n, self.a, self.b = 0, 0, 1
def __iter__(self):
return self
def next(self):
if self.n < self.max_num:
r = self.b
self.a, self.b = self.b, self.a + self.b
self.n += 1
return r
raise StopIteration()
生成器实现Fibonacci数列¶
def fib3(max_num):
n, a, b = 0, 0, 1
while n < max_num:
yield b
a, b = b, a + b
n += 1
>>> g_gen = fib3(10)
>>> g_gen
<generator object fib3 at 0x0000000002716678>
>>> for i in g_gen:
print i
1
1
2
3
5
8
13
21
34
55
协程 coroutine¶
生成器是数据的生产者，协程则是数据的消费者。
def my_coroutine(a=None):
print 'coroutine start...'
while True:
f = (yield a)
print 'result: {}'.format(f)
>>> c = my_coroutine()
>>> next(c)
coroutine start...
>>> c.send('first')
result: first
>>> c.send('second')
result: second
>>> c.close()
字典¶
字典是由键key和值value的对应组合成的无序的序列。
字典构造¶
>>> dict([('a', '1'), ('b', '2')])
{'a': '1', 'b': '2'}
>>> dict.fromkeys(['a', 'b'], 1)
{'a': 1, 'b': 1}
>>> dict.fromkeys('ab', 1)
{'a': 1, 'b': 1}
>>> {'a':'1', 'b':'2'}
{'a': '1', 'b': '2'}
>>> dict(zip(['a', 'b'], ['1', '2']))
{'a': '1', 'b': '2'}
>>> dict([('a', '1'), ('b', '2')])
{'a': '1', 'b': '2'}
>>> dict(a='1', b='2')
{'a': '1', 'b': '2'}
>>> dict(a=1, b=2)
{'a': 1, 'b': 2}
判断一个字典是否有某个key¶
key in Dict
Dict.has_key(key)
获得指定key的值¶
Dict.get(key, default)
# 如果没有key，返回default值，在Dict中不添加该键值。
Dict.setdefault(key, default)
# 如果没有key，返回default值，并且在Dict中添加该键值。
Dict[key] # 如果没有key，返回error。
items(), keys(), values()¶
>>> Dict = {'a':1, 'b':2, 'c':3, 'd':4}
>>> Dict.items()
[('a', 1), ('c', 3), ('b', 2), ('d', 4)]
>>> Dict.keys()
['a', 'c', 'b', 'd']
>>> Dict.values()
[1, 3, 2, 4]
>>> Dict.iteritems()
<dictionary-itemiterator object at 0x0000000002BBACC8>
>>> for k, v in Dict.iteritems():
print k, v
a 1
c 3
b 2
d 4
>>> Dict.iterkeys()
<dictionary-keyiterator object at 0x0000000002BBACC8>
>>> Dict.itervalues()
<dictionary-valueiterator object at 0x0000000002BBAD18>
>>> dct = dict()
>>> dct['foo']
Traceback (most recent call last):
File "<pyshell#55>", line 1, in <module>
dct['foo']
KeyError: 'foo'
特殊方法 __missing__¶
class Dict(dict):
def __missing__(self, key): ## 当查找不到key的时候，会执行该方法
self[key] = []
return self[key]
>>> dct = Dict()
>>> dct['foo']
[]
按照values值进行降序排列¶
>>> x = {'a': 2, 'b': 4, 'c': 3, 'd': 1, 'e': 0}
>>> x.items()
[('a', 2), ('c', 3), ('b', 4), ('e', 0), ('d', 1)]
方法1
>>> sorted_x = sorted(x.items(), key=lambda xx:xx[1], reverse=True)
>>> sorted_x
[('b', 4), ('c', 3), ('a', 2), ('d', 1), ('e', 0)]
方法2
>>> sorted_x = x.items()
>>> sorted_x.sort(key=lambda xx:xx[1], reverse=True)
>>> sorted_x
[('b', 4), ('c', 3), ('a', 2), ('d', 1), ('e', 0)]
合并字典¶
def merge(ds):
r = {}
for d in ds:
for k in d:
if k in r:
r[k] += d.get(k)
else:
r[k] = d.get(k)
return r
>>> d1 = {'a':1, 'b':2, 'c':3}
>>> d2 = {'b':4, 'd':5, 'e':6}
>>> d3 = {'b':3, 'c':1, 'e':1}
>>> d = merge([d1, d2, d3])
>>> d
{'a': 1, 'c': 4, 'b': 9, 'e': 7, 'd': 5}
集合¶
集合与字典类似，也是一组key的集合，但不存储value。
集合构造¶
>>> set(['a', 'b', 'c'])
set(['a', 'c', 'b'])
>>> set('abc')
set(['a', 'c', 'b'])
>>> {'a', 'b', 'c'}
set(['a', 'c', 'b'])
交集、并集、差集、对称差集¶
x.intersection(y) 或 x&y
x.union(y) 或 x|y
x.difference(y) 或 x-y
x.symmetric_difference(y) 或 x^y
类与对象¶
普通继承¶
class Bird(object):
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaah...'
self.hungry = False
else:
print 'No, thanks!'
class SongBird(Bird):
def sing(self):
pass
>>> s = SongBird()
>>> s.sing()
>>> s.eat()
Aaaah...
>>> s.eat()
No, thanks!
super继承¶
class SongBird(Bird):
def __init__(self):
self.sound = 'Squawk!'
def sing(self):
print self.sound
>>> s = SongBird()
>>> s.sing()
Squawk!
>>> s.eat()
Traceback (most recent call last):
File "<pyshell#67>", line 1, in <module>
s.eat()
File "<pyshell#53>", line 5, in eat
if self.hungry:
AttributeError: 'SongBird' object has no attribute 'hungry'
super继承¶
class SongBird(Bird):
def __init__(self):
# Bird.__init__(self)
super(SongBird, self).__init__()
self.sound = 'Squawk!'
def sing(self):
print self.sound
>>> s = SongBird()
>>> s.sing()
Squawk!
>>> s.eat()
Aaaah...
>>> s.eat()
No, thanks!
直接调用内部属性¶
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
>>> s = Student('Bart', 59)
>>> s.score
59
>>> s.score = 60
>>> '%s: %s' % (s.name, s.score)
'Bart: 60'
通过类成员访问内部属性¶
class Student(object):
def __init__(self, name, score):
self._name = name
self._score = score
def get_score(self):
return self._score
def set_score(self, value):
self._score = value
def print_score(self):
print '%s: %s' % (self._name, self._score)
>>> s = Student('Bart', 59)
>>> s.get_score()
59
>>> s.set_score(60)
>>> s.print_score()
Bart: 60
@property与property()¶
class Student(object):
def __init__(self, name, score):
self._name = name
self._score = score
@property
def score(self):
return self._score
@score.setter
def score(self, value):
self._score = value
@score.deleter
def score(self):
del self._score
>>> s = Student('Bart', 59)
>>> s.score
59
>>> s.score = 60
>>> s.score
60
>>> del s.score
@property与property()¶
class Student(object):
def __init__(self, name, score):
self._name = name
self._score = score
def get_score(self):
return self._score
def set_score(self, value):
self._score = value
def del_score(self):
del self._score
score = property(get_score, set_score, del_score)
>>> s = Student('Bart', 59)
>>> s.score
59
>>> s.score = 60
>>> s.score
60
>>> del s.score
动态绑定¶
from types import MethodType
class Student(object):
pass
def set_age(self, age):
self.age = age
def set_score(self, score):
self.score = score
>>> s = Student()
>>> s.name = 'Michael'
>>> s.name
'Michael'
>>> s.set_age = MethodType(set_age, s, Student)
>>> s.set_age(25)
>>> s.age
25
>>> Student.set_score = MethodType(set_score, None, Student)
>>> s.set_score(100)
>>> s.score
100
限制变量 __slots__¶
from types import MethodType
class Student(object):
__slots__ = ('name', 'age', 'set_age')
>>> s = Student()
>>> s.name = 'Michael'
>>> s.name
'Michael'
>>> s.set_age = MethodType(set_age, s, Student)
>>> s.set_age(25)
>>> s.age
25
>>> Student.set_score = MethodType(set_score, None, Student)
>>> s.set_score(100)
Traceback (most recent call last):
File "<pyshell#136>", line 1, in <module>
s.set_score(100)
File "<pyshell#120>", line 2, in set_score
self.score = score
AttributeError: 'Student' object has no attribute 'score'
type 动态创建类¶
def __init__(cls, func):
cls.func = func
def hello(cls):
print 'hello world'
Hello = type('Hello', (object,),
{'__init__':__init__, 'hello':hello})
>>> h = Hello(lambda a, b: a+b)
>>> h.hello()
hello world
>>> type(Hello)
<type 'type'>
>>> type(h)
<class '__main__.Hello'>
元类 __metaclass__ 动态创建类¶
class HelloMeta(type):
def __new__(cls, name, bases, dct):
def __init__(cls, func):
cls.func = func
def hello(cls):
print 'hello world'
# t = type.__new__(cls, name, bases, dct)
t = super(HelloMeta, cls).__new__(cls, name, bases, dct)
t.__init__ = __init__
t.hello = hello
return t
class New_Hello(object):
__metaclass__ = HelloMeta
>>> h = New_Hello(lambda a, b: a+b)
>>> h.hello()
hello world
>>> type(New_Hello)
<class '__main__.HelloMeta'>
>>> type(h)
<class '__main__.New_Hello'>
魔法方法 Magic Method¶
会话管理器¶
enter：定义当使用with语句定义一个代码块时会话管理器应该做什么。
exit：定义当一个代码块被执行或者终止后会话管理器应该做什么。
class FileObject(object):
def __init__(self, filepath='sample.txt'):
self.file = open(filepath, 'r+')
def __enter__(self): # 与with语句对应
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
self.file.close()
del self.file
with FileObject() as fp:
print fp.read()
对象的魔法方法¶
getattr：查询不在dict系统中的对象属性或者对象方法。
class A(object):
def __getattr__(self, attr):
def _(*args, **kw):
print args, kw
return _
pass
>>> a = A()
>>> a.xxx
<function _ at 0x0000000002C05F28>
>>> a.xxx1(1, 2, key='ssss')
(1, 2) {'key': 'ssss'}
>>> a.xxx2(1, 2)
(1, 2) {}
>>> a.xxx3(1, 2, 3)
(1, 2, 3) {}
魔法方法举例¶
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name: %s)' % self.name
def __call__(self):
print 'Student object (name: %s)' % self.name
def __getattr__(self, attr):
if attr == 'score':
return 99
else:
def func(*args, **kw):
return args, kw
return func
魔法方法举例¶
>>> print(s) # 调用__str__方法
Student object (name: Michael)
>>> s() # 调用__call__方法
Student object (name: Michael)
>>> s.name # 调用存在的属性name
'Michael'
>>> s.score # 调用不存在的属性score
99
>>> s.score1 # 调用不存在的属性score1
<function func at 0x0000000002B3E9E8>
>>> s.function(1, 2, 3) # 调用不存在的方法function
((1, 2, 3), {})
函数的参数传递¶
参数定义¶
在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。
def func(a, b, c=0, *args, **kw):
print 'a =', a, 'b =', b, 'c =', c, \
'args =', args, 'kw =', kw
>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}
默认参数¶
默认参数必须为不可变对象，如None，string，tuple，不可为list类型。
def add_end(L=[]):
L.append('END')
return L
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
改为
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
可变参数¶
任意函数都可以表示成func(*args, **kw)形式。
def func(a, b, c):
print a, b, c
>>> l = [1, 2, 3]
>>> d = {'a':1, 'b':2, 'c':3}
>>> func(*l)
1 2 3
>>> func(**d)
1 2 3
函数式编程¶
map(), reduce(), filter()¶
>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> map(lambda x:x*2, range(0,10))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> reduce(lambda x,y:x*10+y, range(0,10))
123456789
>>> filter(lambda x:x%2==0, range(0,10))
[0, 2, 4, 6, 8]
偏函数 partial¶
不需要定义新的函数，把函数的某些参数固定，返回一个新的函数。
实现sequence的加法和乘法¶
>>> from functools import partial
>>> import operator
>>> l = [i for i in range(1, 10)]
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sum = partial(reduce, operator.add)
>>> sum(l)
45
>>> product = partial(reduce, operator.mul)
>>> product(l)
362880
闭包 closure¶
指延伸了作用域的函数，它能访问定义体之外定义的环境变量，这个函数和它的环境变量合在一起，就构成了一个闭包。
def lazy_sum(*args):
def sum(x=0): # sum函数和变量args构成闭包
ax = x
for n in args: # 闭包变量args是只读的，不能修改
ax = ax + n
return ax
return sum
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>>
>>> f
<function sum at 0x0000000002B3E208>
>>> f()
25
>>> f(1)
26
装饰器 decorator¶
不修改函数的定义，在代码运行期间动态增加功能的方式。
函数装饰器¶
def decorator(func):
def wrapper(*args, **kw):
print 'input:', args, kw
return func(*args, **kw)
return wrapper
@decorator
def square_sum(*args, **kw):
sum = 0
for i in args:
sum += i**2
for j in kw.values():
sum += j**2
return sum
>>> square_sum(3, 4, key=5)
input: (3, 4) {'key': 5}
50
类装饰器¶
class decorator(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kw):
print 'input:', args, kw
return self.func(*args, **kw)
@decorator
def square_sum(*args, **kw):
sum = 0
for i in args:
sum += i**2
for j in kw.values():
sum += j**2
return sum
>>> square_sum(3, 4, key=5)
input: (3, 4) {'key': 5}
50
带参数的装饰器¶
def decorator(*args, **kw):
text = args
def _(func):
def wrapper(*args, **kw):
print 'text: %s' % text
print 'input:', args, kw
return func(*args, **kw)
return wrapper
return _
注意：decorator中的(*args, **kw) vs wrapper中的(*args, **kw)
联系方式¶
Website: 宁哥的小站
GitHub: lining0806
Gmail: lining0806@gmail.com
如果你觉得文档对你的有所帮助，欢迎扫下面的二维码对作者进行小额赞助，以鼓励作者进一步完善文档内容，提高文档质量。
小额赞助（微信扫码）¶
