Python 基础回顾（五）

热个身？

1.

f(0) = 1

f(1) =1

f(2) = f(1) + f(0)

…

f(n) = f(n-1) + f(n-2)

求 f(n) 这个函数该如何定义。

1) 递归方法

2) 循环

def f(n):

if n == 0 or n == 1:

return 1

else:

return f(n-1) + f(n-2)

def f(n):

if n == 0 or n == 1: # n == 0 为 第一个数， n == 1 为第二个数

return 1

first = 1

second = 1

for i in range(2, n+1):

f(n) = f(n-1) + f(n-2)

f(n-1) = f(n-1 - 1) + f(n-1 -2) = f(n-2) + f(n-3)

2.

g(x)，判断一个字符串是否是回文串， 类似:

‘aba’

‘abba’

‘abcba’ 是回文串

而 ‘abb’ 这样的就不是

思路 1. 收尾对应比较

思路 2. 字符串翻转，对比

书写函数几个法则：

1. 动手之前先想想

2. 看起来不是超复杂， 嵌套不要多于4层

3. 多写写，优化一下

4. 先解决问题，再优雅的解决问题

5. 测试，多写几个程序验证一下你的解法

6. 写起来感觉很难，那就加个注释，汉语都说不明白？走错路了吧

7. 一次干好一件事！！！

定义一个函数： 消除列表中的重复元素

定义类 Point. 来描述平面上的一个点(x,y).

class Point(object):

def init(self,x,y):

self.x = x

self.y = y

def get_x(self):
return self.x
def get_y(self):
return self.y

def distance(self, other_point):
dis = (self.x – other_point.x)**2 + (self.y – other_point.y) ** 2
return genhao(dis)
def __str__(self):
return “( {0},{1} )”.format(self.x, self.y)

a = Point(3,4)

b = Point(4,5)

b = 123

dis = a.distance(b)

定义一个图书馆系统：面向对象, 这可如何要弄？

添加/删除 书籍：

查找书籍：

借阅书籍：

关于类？

正常情况下，当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。先定义class：

class Student(object):

… pass

…

然后，尝试给实例绑定一个属性：

s = Student()

s.name = ‘lxf’ # 动态给实例绑定一个属性

print s.name

lxf

还可以尝试给实例绑定一个方法：

def set_age(self, age): # 定义一个函数作为实例方法

… self.age = age

…

from types import MethodType

s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法

s.set_age(25) # 调用实例方法

s.age # 测试结果

25

但是，给一个实例绑定的方法，对另一个实例是不起作用的：

s2 = Student() # 创建新的实例

s2.set_age(25) # 尝试调用方法

Traceback (most recent call last):

File “”, line 1, in

AttributeError: ‘Student’ object has no attribute ‘set_age’

为了给所有实例都绑定方法，可以给class绑定方法：

def set_score(self, score):

… self.score = score

…

Student.set_score = MethodType(set_score, None, Student)

给class绑定方法后，所有实例均可调用：

s.set_score(100)

s.score

100

s2.set_score(99)

s2.score

99

通常情况下，上面的set_score方法可以直接定义在class中，但动态绑定允许我们在程序运行的过程中动态给class加上功能，这在静态语言中很难实现。

使用slots

但是，如果我们想要限制class的属性怎么办？比如，只允许对Student实例添加name和age属性。

为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的slots变量，来限制该class能添加的属性：

class Student(object):

… slots = (‘name’, ‘age’) # 用tuple定义允许绑定的属性名称

…

然后，我们试试：

s = Student() # 创建新的实例

s.name = ‘lxf’ # 绑定属性’name’

s.age = 25 # 绑定属性’age’

s.score = 99 # 绑定属性’score’

Traceback (most recent call last):

File “”, line 1, in

AttributeError: ‘Student’ object has no attribute ‘score’

由于’score’没有被放到slots中，所以不能绑定score属性，试图绑定score将得到AttributeError的错误。

使用slots要注意，slots定义的属性仅对当前类起作用，对继承的子类是不起作用的：

class GraduateStudent(Student):

… pass

…

g = GraduateStudent()

g.score = 99

除非在子类中也定义slots，这样，子类允许定义的属性就是自身的slots加上父类的slots。

一个有趣的装饰器

在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以随便改成绩：

s = Student()

s.score = 101

这显然不合逻辑。为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

class Student(object):

def get_score(self):
return self._score

def set_score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 and 100!')
self._score = value

现在，对任意的Student实例进行操作，就不能随心所欲地设置score了：

s = Student()

s.set_score(60) # ok!

s.get_score()

60

s.set_score(101)

Traceback (most recent call last):

…

ValueError: score must between 0 and 100!

但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。

有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？这个是可以有的！

还记得装饰器（decorator）可以给函数动态加上功能吗？对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object):

@property
def score(self):
return self._score

@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 and 100!')
self._score = value

@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

s = Student()

s.score = 60 # OK，实际转化为s.set_score(60)

s.score # OK，实际转化为s.get_score()

60

s.score = 101

Traceback (most recent call last):

…

ValueError: score must between 0 and 100!

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。

还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object):

@property
def birth(self):
return self._birth

@birth.setter
def birth(self, value):
self._birth = value

@property
def age(self):
return 2015 - self._birth

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来。

小结

@property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。

定制类

看到类似slots这种形如xxx的变量或者函数名就要注意，这些在Python中是有特殊用途的。

slots我们已经知道怎么用了除此之外，Python的class中还有许多这样有特殊用途的函数，可以帮助我们定制类。

str

我们先定义一个Student类，打印一个实例：

class Student(object):

… def init(self, name):

… self.name = name

…

print Student(‘lxf’)

<main.Student object at 0x109afb190>

打印出一堆<main.Student object at 0x109afb190>，不好看。

怎么才能打印得好看呢？只需要定义好str()方法，返回一个好看的字符串就可以了：

class Student(object):

… def init(self, name):

… self.name = name

… def str(self):

… return ‘Student object (name: %s)’ % self.name

…

print Student(‘lxf’)

Student object (name: lxf)

这样打印出来的实例，不但好看，而且容易看出实例内部重要的数据。

但是细心的朋友会发现直接敲变量不用print，打印出来的实例还是不好看：

s = Student(‘lxf’)

s

<main.Student object at 0x109afb310>

s = ‘123’

repr(s)

这是因为直接显示变量调用的不是str()，而是repr()，两者的区别是str()返回用户看到的字符串，而repr()返回程序开发者看到的字符串，也就是说，repr()是为调试服务的。

解决办法是再定义一个repr()。但是通常str()和repr()代码都是一样的，所以，有个偷懒的写法：

class Student(object):

def init(self, name):

self.name = name

def str(self):

return ‘Student object (name=%s)’ % self.name

repr = str

iter

如果一个类想被用于for … in循环，类似list或tuple那样，就必须实现一个iter()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的next()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

我们以斐波那契数列为例，写一个Fib类，可以作用于for循环：

class Fib(object):

def init(self):

self.a, self.b = 1, 1

def iter(self):

return self # 实例本身就是迭代对象，故返回自己

def next(self):

self.a, self.b = self.b, self.a + self.b # 计算下一个值

if self.a > 100000: # 退出循环的条件

raise StopIteration()

return self.a # 返回下一个值

现在，试试把Fib实例作用于for循环：

for n in Fib():

… print n

1

1

2

3

5

…

46368

75025

class Reverse(object):

def init(self, a_str):

self.xstr = a_str

self.len = len(a_str)

def iter(self):

return self

def next(self):

if self.len ==0:

raise StopIteration()

self.len = self.len -1

return self.xstr[self.len]

for i in Reverse(‘abc’):

print i

c

b

a

getattr

正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错。比如定义Student类：

class Student(object):

def __init__(self):
self.name = 'lxf'

调用name属性，没问题，但是，调用不存在的score属性，就有问题了：

s = Student()

print s.name

Michael

print s.score

Traceback (most recent call last):

…

AttributeError: ‘Student’ object has no attribute ‘score’

错误信息很清楚地告诉我们，没有找到score这个attribute。

要避免这个错误，除了可以加上一个score属性外，Python还有另一个机制，那就是写一个getattr()方法，动态返回一个属性。修改如下：

class Student(object):

def __init__(self):
self.name = 'lxf'
def __getattr__(self, attr):
if attr=='score':
return 99

当调用不存在的属性时，比如score，Python解释器会试图调用getattr(self, ‘score’)来尝试获得属性，这样，我们就有机会返回score的值：

s = Student()

s.name

‘lxf’

s.score

99

返回函数也是完全可以的：

class Student(object):

def __getattr__(self, attr):
if attr=='age':
return lambda: 18

只是调用方式要变为：

s.age()

18

注意，只有在没有找到属性的情况下，才调用getattr，已有的属性，比如name，不会在getattr中查找。

此外，注意到任意调用如s.abc都会返回None，这是因为我们定义的getattr默认返回就是None。要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误：

class Student(object):

def __getattr__(self, attr):
if attr=='age':
return lambda: 25
raise AttributeError('Student object has no attribute \'%s\'' % attr)

这实际上可以把一个类的所有属性和方法调用全部动态化处理了，不需要任何特殊手段。

这种完全动态调用的特性有什么实际作用呢？作用就是，可以针对完全动态的情况作调用。

call

一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用。能不能直接在实例本身上调用呢？类似instance()？在Python中，答案是肯定的。

任何类，只需要定义一个call()方法，就可以直接对实例进行调用。请看示例：

class Student(object):

def init(self, name):

self.name = name

def __call__(self):
print('My name is %s.' % self.name)

调用方式如下：

s = Student(‘lxf’)

s()

My name is lxf.

call()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。

如果你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的，这么一来，我们就模糊了对象和函数的界限。

那么，怎么判断一个变量是对象还是函数呢？其实，更多的时候，我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有call()的类实例：

callable(Student())

True

callable(max)

True

callable([1, 2, 3])

False

callable(None)

False

callable(‘string’)

False

通过callable()函数，我们就可以判断一个对象是否是“可调用”对象。

小结

Python的class允许定义许多定制方法，可以让我们非常方便地生成特定的类。

本节介绍的是最常用的几个定制方法，还有很多可定制的方法…

数据库

数据库（Database）这种专门用于集中存储和查询的软件：

数据库，网络，操作系统，数据结构，计算机科学的基础科目