python定制类

发表于 | 分类于 | 阅读次数: |
字数统计: 2.7k 字 | 阅读时长 ≈ 12 分钟

图
定制类的目的：是为了让我们编写的类能够应用到普通的函数中，比如像len()、compare()函数这些，为了实现这个目的，就需要实现特殊方法，



定制类

特殊方法

比较print的结果：

1
2
3
4
5
>>>print lst
[1, 2, 3]

>>>print p    # p是Person类一个对象
< __main__.Person object at  0x10da9e850>

python是如何把任意变量变成str的呢？

因为任何数据类型的实例都有一个特殊方法： str ()

1
2
3
4
5
>>>python lst.__str__()
[1, 2, 3]

>>>print p.__str__()    # p是Person类一个对象
< __main__.Person object at  0x10da9e850>

如果给Person类加上 str()这个特殊方法，我们就可以按照自己的想法打印出Person的这个实例来。

1
2
3
>>>p = Person('Bob', 'male')
>>>print p
<Person: Bob, male>

python的特殊方法：
用于print的 str()
用于len的 len()
用于cmp的 cmp() ……
在这里插入图片描述

python特殊方法的特点：

  1. 特殊方法定义在class中
  2. 不需要直接调用
  3. python的某些函数或者操作符会调用对应的特殊方法

如何正确实现特殊方法：

  1. 只需要编写用到的特殊方法
  2. 有关联性的特殊方法都必须实现
    (要写一个getattr ，就必须同时实现setattr() , delattr() )

Python中 str 和 repr

如果要把一个类的实例变成 str，就需要实现特殊方法str()：

1
2
3
4
5
6
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return '(Person: %s, %s)' % (self.name, self.gender)

现在，在交互式命令行下用 print 试试：

1
2
3
>>> p = Person('Bob', 'male')
>>> print p
(Person: Bob, male)

如果直接敲变量 p：

1
2
>>> p
<main.Person object at 0x10c941890>

似乎str() 不会被调用。

因为 Python 定义了str()和repr()两种方法， str()用于显示给用户，而repr()用于显示给开发人员。

有一个偷懒的定义repr的方法：

1
__repr__ = __str__

Python中 cmp

对 int、str 等内置数据类型排序时，Python的 sorted() 按照默认的比较函数 cmp 排序，但是，如果对一组 Student 类的实例排序时，就必须提供我们自己的特殊方法 cmp ()：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def __str__(self):
        return '(%s: %s)' % (self.name, self.score)
    __repr__ = __str__

    def __cmp__(self, s):
        if self.name < s.name:
            return -1
        elif self.name > s.name:
            return 1
        else:
            return 0

上述 Student 类实现了cmp()方法，cmp用实例自身self和传入的实例 s 进行比较，如果 self 应该排在前面，就返回 -1，如果 s 应该排在前面，就返回1，如果两者相当，返回 0。

Student类实现了按name进行排序：

1
2
3
>>> L = [Student('Tim', 99), Student('Bob', 88), Student('Alice', 77)]
>>> print sorted(L)
[(Alice: 77), (Bob: 88), (Tim: 99)]

注意: 如果list不仅仅包含 Student 类，则 cmp 可能会报错：

Python中len

如果一个类表现得像一个list，要获取有多少个元素，就得用 len() 函数。
要让 len() 函数工作正常，类必须提供一个特殊方法len()，它返回元素的个数。
例如，我们写一个 Students 类，把名字传进去：

1
2
3
4
5
class Students(object):
    def __init__(self, *args):
        self.names = args
    def __len__(self):
        return len(self.names)

只要正确实现了len()方法，就可以用len() 函数返回Students实例的“长度”：

1
2
3
4

>>> ss = Students('Bob', 'Alice', 'Tim')
>>> print len(ss)
3

知识点回顾： 可变参数——python基础语法
如果想让一个函数接受任意个参数，可以顶一个可变参数。可变参数名字前面有个号，可传入多个参数给可变参数。
`def fn(args)print args`
Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量args看成一个tuple就好了。

Python中数学运算

Python 提供的基本数据类型 int、float 可以做整数和浮点的四则运算以及乘方等运算。

但是，四则运算不局限于int和float，还可以是有理数、矩阵等。

要表示有理数，可以用一个Rational类来表示：

1
2
3
4
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q

p、q 都是整数，表示有理数 p/q。

如果要让Rational进行+运算，需要正确实现add：

1
2
3
4
5
6
7
8
9
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __str__(self):
        return '%s/%s' % (self.p, self.q)
    __repr__ = __str__

现在可以试试有理数加法：

1
2
3
4
>>> r1 = Rational(1, 3)
>>> r2 = Rational(1, 2)
>>> print r1 + r2
5/6

实现Rational类的四则运算：
加法：add
减法：sub
乘法：mul
除法：div

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def gcd(a, b):    #约分，找出分子分母的最大公约数
    if b == 0:
        return a
    return gcd(b, a % b)
    
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
        
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __sub__(self, r):
        return Rational(self.p * r.q - self.q * r.p, self.q * r.q)
    def __mul__(self, r):
        return Rational(self.p * r.p, self.q * r.q)
    def __div__(self, r):
        return Rational(self.p * r.q, self.q * r.p)
        
    def __str__(self):
        g = gcd(self.p, self.q)    #分子分母的最大公约数g
        return '%s/%s' % (self.p / g, self.q / g)
    __repr__ = __str__

测试结果如下：

1
2
3
4
5
6
7
8
9
10
11
r1 = Rational(1, 2)
r2 = Rational(1, 4)
print r1 + r2
print r1 - r2
print r1 * r2
print r1 / r2

3/4
1/4
1/8
2/1

python中类型转换

Rational类实现了有理数运算，但是，如果要把结果转为 int 或 float 怎么办？

已学过整数和浮点数的转换：

>>> int(12.34)
12
>>> float(12)
12.0

如果要把 Rational 转为 int，应该使用：

r = Rational(12, 5)
n = int(r)

要让 int() 函数正常工作，只需要实现特殊方法int():
同理，要让 float() 函数正常工作，只需要实现特殊方法float()。

1
2
3
4
5
6
7
8
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __int__(self):
        return self.p // self.q
  def __float__(self):
      return  float(self.p) /  self.q

结果如下：

1
2
3
4
5
6
7
8
>>> print int(Rational(7, 2))
3
>>> print int(Rational(1, 3))
0   
>>>print float(Rational(7, 2))
3.5
>>>print float(Rational(1, 3))
0.333333333333

python中 @property

类比C#中的 属性get/set, get读取属性值，set设置属性值

当我们想要修改一个 Student 的 scroe 属性时，可以这么写：

1
2
3
s = Student('Bob', 59)
s.score = 60
s.score = 1000

显然，直接给属性赋值无法检查分数的有效性。

如果利用两个方法：

1
2
3
4
5
6
7
8
9
10
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, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score

这样一来，s.set_score(1000) 就会报错。

这种使用 get/set 方法来封装对一个属性的访问在许多面向对象编程的语言中都很常见。

但是写 s.get_score() 和 s.set_score() 没有直接写 s.score 来得直接。

有一个两全其美的方法——
因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法装饰成属性调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score
    #自定义grade属性，可根据score计算A、B、C    
    @property
    def grade(self):
        if self.score < 60:
            return 'C'
        if self.score < 80:
            return 'B'
        return 'A'

注意: 第一个score(self)是get方法，用@property装饰；第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品。
现在，就可以像使用属性一样设置score了：

结果如下：

1
2
3
4
5
6
7
8
9
10
>>> s = Student('Bob', 59)
>>> s.score = 60
>>> print s.score
60
>>> s.score = 1000
Traceback (most recent call last):
  ...
ValueError: invalid score
>>>print s.grade
B

说明对 score 赋值实际调用的是 set方法。

python中 slots

由于Python是动态语言，任何实例在运行期都可以动态地添加属性。

如果要限制添加的属性，例如，Student类只允许添加 name、gender和score 这3个属性，就可以利用Python的一个特殊的slots来实现。

slots是指一个类允许的属性列表：

1
2
3
4
5
6
class Student(object):
    __slots__ = ('name', 'gender', 'score')
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score

测试结果如下：

s 
1
2
3
4
5
6
>>> s.name = 'Tim' # OK
>>> s.score = 99 # OK
>>> s.grade = 'A'
Traceback (most recent call last):
  ...
AttributeError: 'Student' object has no attribute 'grade'

slots的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用slots也能节省内存。

应用: 假设Person类通过slots定义了name和gender，请在派生类Student中通过slots继续添加score的定义，使Student类可以实现name、gender和score 3个属性。
Student类的slots只需要包含Person类不包含的score属性即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Person(object):

    __slots__ = ('name', 'gender')

    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Student(Person):

    __slots__ = ('score',)    #name, gender不用再写出来

    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)  #super.__init()初始化父类属性，不要忘记调用！
        self.score = score

s = Student('Bob', 'male', 59)
s.name = 'Tim'
s.score = 99
print s.score

python中 call

在Python中，函数其实是一个对象：

1
2
3
4
5
>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)
123

由于 f 可以被调用，所以，f 被称为可调用对象。

所有的函数都是可调用对象。

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法call()。

我们把 Person 类变成一个可调用对象：

这样就可以 调用函数 那样来 调用一个类对象实例

首先把Person类变成一个可调用对象：

1
2
3
4
5
6
7
8
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

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

现在可以对 Person 实例直接调用：

1
2
3
4
>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...

注意： 单看 p(‘Tim’) 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。

之前写过一个斐波那契数列函数：
class Fib(object):
现在加一个call方法，让调用可以更简单：

1
2
3
4
5
6
7
8
9
10
class Fib(object):
    def __call__(self, num):
        a, b, L = 0, 1, []
        for n in range(num):
            L.append(a)
            a, b = b, a+b
        return L

f = Fib()
print f(10)    #调用Fib类就像调用函数一样，非常方便

总结

语法到此基本学完，下面就可以学一些更深层的内容，比如：
IO：文件和Socket
多任务：进程和线程
数据库： python支持一个通用的db API，可以连接各种不同的关系数据库。
Web开发：可以构建一个基于Web的服务，

坚持原创分享，您的支持将鼓励我继续创作！