类和对象

改变对象的字符串显示

问题：

　　你想改变对象实例的打印或显示输出，让它们更具可读性

解决方案：

　　要改变一个实例的字符串表示，可重新定义它的str () 和repr () 方法。例如：

class Pair:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        #另外一种写法 return 'Pair(%r,%r)'%(self.x, self.y )
        return 'Pair({0.x!r}, {0.y!r})'.format(self)

    def __str__(self):
        return '({0.x!s}, {0.y!s})'.format(self)

p = Pair(3, 4)

print("__str__()的输出效果:", p)

print('__repr__()的输出效果:', repr(p))

以上代码执行的结果为:

__str__()的输出效果: (3, 4)
__repr__()的输出效果: Pair(3, 4)

自定义字符串的格式化

问题：

　　你想通过format() 函数和字符串方法使得一个对象能支持自定义的格式化。

解决方案：

　　为了自定义字符串的格式化，我们需要在类上面定义format () 方法。例如：

_formats = {
    'ymd' : '{d.year}-{d.month}-{d.day}',
    'mdy' : '{d.month}/{d.day}/{d.year}',
    'dmy' : '{d.day}/{d.month}/{d.year}'
    }

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __format__(self, format_spec):
        if format_spec == '':
            format_spec = 'ymd'

        fmt = _formats[format_spec]
        return fmt.format(d=self)

d = Date(2017, 8, 7)
print('默认格式的输出:', format(d))

print('mdy类型的输出:', format(d, 'mdy'))

print('The date is {:ymd}'.format(d))

print('The date is {:mdy}'.format(d))

from datetime import  date
d = date(2017, 8, 7)
print(format(d))

print(format(d,'%A, %B %d, %Y'))

print('The end is {:%d %b %Y}. Goodbye'.format(d))

以上代码执行的结果为:

默认格式的输出: 2017-8-7
mdy类型的输出: 8/7/2017
The date is 2017-8-7
The date is 8/7/2017
2017-08-07
Monday, August 07, 2017
The end is 07 Aug 2017. Goodbye

让对象支持上下文管理协议

问题：

　　你想让你的对象支持上下文管理协议(with 语句)　

解决方案：　　

　　为了让一个对象兼容with 语句，你需要实现enter () 和exit () 方法。例如，考虑如下的一个类，它能为我们创建一个网络连接：

from socket import socket,AF_INET,SOCK_STREAM

class LazyConnection:
    '''
    连接端
    '''
    def __init__(self, addresss, family=AF_INET, type=SOCK_STREAM):
        self.address = addresss
        self.family = family
        self.type = type
        self.sock = None

    def __enter__(self):
        if self.sock is not None:
            raise RuntimeError('Already connected')

        self.sock = socket(self.family, self.type)
        self.sock.connect(self.address)
        return self.sock

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.sock.close()
        self.sock = None


from functools import partial

conn = LazyConnection(('www.python.org', 80))

with conn as s:
    '''
    通过with管理上下文
    '''
    # conn.__enter__() executes: connection open
    s.send(b'GET /index.html HTTP/1.0
')
    s.send(b'Host: www.python.org
')
    s.send(b'
')
    resp = b''.join(iter(partial(s.recv, 8192), b'')).decode('utf-8')
    # conn.__exit__() executes: connection closed
    print(resp)

以上代码执行的结果为:

HTTP/1.1 301 Moved Permanently
Server: Varnish
Retry-After: 0
Location: https://www.python.org/index.html
Content-Length: 0
Accept-Ranges: bytes
Date: Mon, 07 Aug 2017 02:34:49 GMT
Via: 1.1 varnish
Connection: close
X-Served-By: cache-nrt6134-NRT
X-Cache: HIT
X-Cache-Hits: 0
X-Timer: S1502073289.426123,VS0,VE0
Strict-Transport-Security: max-age=63072000; includeSubDomains

总结：　 

　　编写上下文管理器的主要原理是你的代码会放到with 语句块中执行。当出现with语句的时候，对象的enter () 方法被触发，它返回的值(如果有的话) 会被赋值给as 声明的变量。然后，with 语句块里面的代码开始执行。最后， exit () 方法被触发进行清理工作。

　　不管with 代码块中发生什么，上面的控制流都会执行完，就算代码块中发生了异常也是一样的。事实上， exit () 方法的第三个参数包含了异常类型、异常值和追溯信息(如果有的话)。exit () 方法能自己决定怎样利用这个异常信息，或者忽略它并返回一个None 值。如果exit () 返回True ，那么异常会被清空，就好像什么都没发生一样， with 语句后面的程序继续在正常执行。

创建大量对象时节省内存方法

问题：

　　你的程序要创建大量(可能上百万) 的对象，导致占用很大的内存

解决方案：

　　对于主要是用来当成简单的数据结构的类而言，你可以通过给类添加slots 属性来极大的减少实例所占的内存。比如：

class Date:
    __slots__ =  ['year', 'month', 'day']
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

注意：

　　当你定义slots 后，Python 就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个字典，这跟元组或列表很类似。在slots 中列出的属性名在内部被映射到这个数组的指定小标上。使用slots 一个不好的地方就是我们不能再给实例添加新的属性了，只能使用在slots中定义的那些属性名

在类中封装属性名

问题：

　　你想封装类的实例上面的“私有”数据，但是Python 语言并没有访问控制

解决方案：　

　　Python 程序员不去依赖语言特性去封装数据，而是通过遵循一定的属性和方法命名规约来达到这个效果。第一个约定是任何以单下划线_开头的名字都应该是内部实现。比如：

class A:
    def __init__(self):
        self._internal = 0
        self.public = 1

    def public_method(self):
        print('public method')

    def _internal_method(self):
        print('internal method')

你还可能会遇到在类定义中使用两个下划线(__ ) 开头的命名。比如：

class B:
    def __init__(self):
        self.__private = 0

    def __private_method(self):
        print('private method...外部不能调用，只能内部中调用')

    def public_method(self):
        print('公用方法调用内部的__private_method..')
        self.__private_method()

　　使用双下划线开始会导致访问名称变成其他形式。比如，在前面的类B 中，私有属性会被分别重命名为_B__ private 和_B __private method 。这时候你可能会问这样重命名的目的是什么，答案就是继承——这种属性通过继承是无法被覆盖的。比如：

class C(B):
    '''
    C类中的__private 在外部调用为_C__private
    C类中的__private_method在外部调用为_C__private_method
    '''

    def __init__(self):
        super().__init__()
        self.__private = 1              #这样写就不会覆盖掉B中的__private

        def __private_mothod(self):     #同样不会覆盖掉B中的__private_method
            print('C类中的private_mothd')

总结：

　　上面提到有两种不同的编码约定(单下划线和双下划线) 来命名私有属性，那么问题就来了：到底哪种方式好呢？大多数而言，你应该让你的非公共名称以单下划线开头。但是，如果你清楚你的代码会涉及到子类，并且有些内部属性应该在子类中隐藏起来，那么才考虑使用双下划线方案。

 

创建可管理的属性

问题：

　　你想给某个实例attribute 增加除访问与修改之外的其他处理逻辑，比如类型检查或合法性验证

解决方案：

　　自定义某个属性的一种简单方法是将它定义为一个property。例如，下面的代码定义了一个property，增加对一个属性简单的类型检查：

class Person:
    def __init__(self, first_name):
        self.first_name = first_name

    @property                                       #把方法变成一个属性，外部调用的时候，不需要加上()
    def first_name(self):
        return self._first_name

    @first_name.setter                              #给frist_name方法接收一个值作为self._first_name的返回
    def first_name(self, value):
        if not isinstance(value, str):
            raise TypeError('Expected a string')
        self._first_name = value

    @first_name.deleter                             #如果first_name属性没被创建则报错
    def first_name(self):
        raise ArithmeticError("Can't delete attribute")

a = Person('demon')
print(a.first_name)

#a.first_name = 50          #报错raise TypeError('Expected a string')

#del a.first_name           #报错ArithmeticError: Can't delete attribute

以上代码执行的结果为:

demon

 使用已存在的get 和set 方法基础上定义property。例如：

class Person:
    def __init__(self, first_name):
        self.set_first_name(first_name)

    def get_first_name(self):
        return self._first_name

    def set_first_name(self, value):
        if not isinstance(value, str):
            raise TypeError('Expected a string')
        self._first_name = value

    def del_first_name(self):
        raise AttributeError("Can't delete attribute")

    name = property(get_first_name, set_first_name, del_first_name)
    

调用父类方法

问题：

　　你想在子类中调用父类的某个已经被覆盖的方法 

解决方案：

　　为了调用父类(超类) 的一个方法，可以使用super() 函数，比如：

class A:
    def spam(self):
        print('A.spam')

class B(A):
    def spam(self):
        print('B.spam')
        super().spam()

a = A()
b = B()

a.spam()            #调用A类中的spam方法
print('我是分割符'.center(50, '*'))
b.spam()            #先调用B类中的spam方法，然后通过super继承A类中的spam方法返回输出

以上代码执行的结果为:

A.spam
**********************我是分割符***********************
B.spam
A.spam

super() 函数的一个常见用法是在init () 方法中确保父类被正确的初始化了：

class A:
    def __init__(self):
        self.x = 0

class B(A):
    def __init__(self):
        super().__init__()
        self.y = 1
        

super() 的另外一个常见用法出现在覆盖Python 特殊方法的代码中，比如：

class Proxy:
    def __init__(self, obj):
        self._obj = obj

    def __getattr__(self, name):
        return getattr(self._obj, name)

    def __setattr__(self, name, value):
        if name.startswith('_'):
            super().__setattr__(name, value)            #__setattr__()实现包含一个名字检查，如果某个属性名称以_开头，就通过super调用
        else:
            setattr(self._obj, name , value)            #否则就委派给内部的_obj来处理

　　在上面代码中， __setattr__ () 的实现包含一个名字检查。如果某个属性名以下划线( _) 开头，就通过super() 调用原始的__setattr__ () ，否则的话就委派给内部的代理对象self. _obj 去处理。这看上去有点意思，因为就算没有显式的指明某个类的父类， super() 仍然可以有效的工作。

子类中扩展property

问题：

　　在子类中，你想要扩展定义在父类中的property 的功能

解决方案：

　　考虑如下的代码，它定义了一个property：

class  Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError('Expected a string')
        self._name = value

    @name.deleter
    def name(self):
        raise AttributeError("Can't delete attribute")


class SubPerson(Person):
    @Person.name.getter
    def name(self):
        print('Getting name')
        return super().name

    @Person.name.setter
    def name(self, value):
        print('Setting name to', value)
        super(SubPerson, SubPerson).name.__set__(self, value)

创建新的类或实例属性

问题：

　　你想创建一个新的拥有一些额外功能的实例属性类型，比如类型检查 

解决方案：

　　如果你想创建一个全新的实例属性，可以通过一个描述器类的形式来定义它的功能。下面是一个例子:

class Integer:
    def __init__(self, name):
        self.name = name

    def __get__(self, instance, cls):
        if instance is None:
            return self
        else:
            return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value, int):
            raise TypeError('Expected an int')
        instance.__dict__[self.name] = value

    def __delattr__(self, instance):
        del instance.__dict__[self.name]


class Point:
    x = Integer('x')
    y = Integer('y')

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(2, 3)
print(p.x)                  #x.__get__(p, Point)
print(p.y)

print(Point.x)              #x.__get__(None, Point) 

super() 的另外一个常见用法出现在覆盖Python 特殊方法的代码中，比如：

2
3
<__main__.Integer object at 0x101c456a0>

使用延迟计算属性

问题：

　　你想将一个只读属性定义成一个property，并且只在访问的时候才会计算结果。但是一旦被访问后，你希望结果值被缓存起来，不用每次都去计算

解决方案： 

　　定义一个延迟属性的一种高效方法是通过使用一个描述器类，如下所示：

class lazyproperty:
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, cls):
        if instance is None:
            return self
        else:
            value = self.func(instance)
            setattr(instance, self.func.__name__, value)
            return value


import math


class Circle:
    def __init__(self, radius):
        self.radius = radius

    @lazyproperty
    def area(self):
        print('Computing area')
        return math.pi * self.radius ** 2

    @lazyproperty
    def perimeter(self):
        print('Computing perimeter')
        return 2 * math.pi * self.radius


c = Circle(4.0)
print('radius:', c.radius)
print('area:', c.area)
print('perimeter:', c.perimeter)

以上代码执行的结果为:

radius: 4.0
Computing area
area: 50.26548245743669
Computing perimeter
perimeter: 25.132741228718345

简化数据结构的初始化

问题：

　　你写了很多仅仅用作数据结构的类，不想写太多烦人的init () 函数

解决方案：

　　可以在一个基类中写一个公用的init () 函数：

import math


class Structurel:
    _fields = []

    def __init__(self, *args):
        if len(args) != len(self._fields):
            raise TypeError('Expected {} arguments'.format(len(self._fields)))
        for name,value in zip(self._fields, args):
            setattr(self, name, value)


class Stock(Structurel):
    _fields = ['name', 'shares', 'price']


class Point(Structurel):
    _fields = ['x', 'y']


class Circle(Structurel):
    _fields = ['radius']

    def area(self):
        return math.pi * self.radius ** 2

s = Stock('ACME', 50, 91.1)
p = Point(2, 3)
c = Circle(4.5)
print(c.area())
# c = Stock('ACME', 50)         #报错，会抛出raise的TypeError的异常

以上代码执行的结果为:

63.61725123519331

定义接口或者抽象基类

问题：

　　你想定义一个接口或抽象类，并且通过执行类型检查来确保子类实现了某些特定的方法

解决方案：

　　使用abc 模块可以很轻松的定义抽象基类：

from abc import ABCMeta, abstractclassmethod

class IStream(metaclass=ABCMeta):
    @abstractclassmethod
    def read(self, maxbytes=-1):
        pass

    @abstractclassmethod
    def write(self, data):
        pass

#抽象类的一个特点是它不能直接被实例化，比如你想像下面这样做是不行的：
#a = IStream()  TypeError Can't instantiate abstract class

#抽象类的目的就是让别的类继承它并实现特定的抽象方法：
class SocketStream(IStream):
    def read(self, maxbytes=-1):
        pass

    def write(self, data):
        pass

实现数据模型的类型约束

问题：　

　　你想定义某些在属性赋值上面有限制的数据结构

解决方案：

　　在这个问题中，你需要在对某些实例属性赋值时进行检查。所以你要自定义属性赋值函数，这种情况下最好使用描述

class Descriptor:
    def __init__(self, name=None, **opts):
        self.name = name
        for key,value in opts.items():
            setattr(self, key, value)

    def __set__(self, instance, value):
        instance.__dict__[self.name] = value


class Typed(Descriptor):
    expected_type = type(None)

    def __set__(self, instance, value):
        if not isinstance(instance, self.expected_type):
            raise TypeError('expected ' + str(self.expected_type))
        super().__set__(instance, value)


class Unsigned(Descriptor):
    def __set__(self, instance, value):
        if value <= 0:
            raise ValueError('Expected >= 0')
        super().__set__(instance, value)


class MaxSized(Descriptor):
    def __init__(self, name=None, **opts):
        if 'size' not in opts:
            raise TypeError('missing size option')
        super().__init__(name, **opts)

    def __set__(self, instance, value):
        if len(value) >= self.size:
            raise ValueError('size must be < ' + str(self.size))
        super().__set__(instance, value)


class Integer(Typed):
    expected_type = int


class UnsignedInteger(Integer, Unsigned):
    pass


class Float(Typed):
    expected_type = float


class UnsignedFloat(Float, Unsigned):
    pass


class String(Typed):
    expected_type = str


class SizedString(String, MaxSized):
    pass


class Stock:
    name = SizedString('name', size=8)
    shares = UnsignedInteger('shares')
    price = UnsignedFloat('price')

    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

实现自定义容器

问题：

　　你想实现一个自定义的类来模拟内置的容器类功能，比如列表和字典。但是你不确定到底要实现哪些方法

解决方案：

　　collections 定义了很多抽象基类，当你想自定义容器类的时候它们会非常有用。比如你想让你的类支持迭代，那就让你的类继承collections.Iterable 即可：

from collections import Iterable


class A(Iterable):

    def __iter__(self):
        return iter()




#另外一种实现的方式
import bisect
import collections

class SortedItem(collections.Sequence):
    def __init__(self, initial=None):
        self._item = sorted(initial) if initial is not None else []

    def __getitem__(self, index):
        return self._item[index]

    def __len__(self):
        return len(self._item)

    def add(self, item):
        bisect.insort(self._item, item)                 #可以保证元素插入后还保持顺序


items = SortedItem([5, 1, 3])
print('列表排序的结果'.center(30, '*'))
print(list(items))
print('获取列表索引位置的值'.center(30, '-'))
print(items[0], items[-1])
print('添加元素以后的列表'.center(30, '*'))
items.add(2)
print(list(items))

以上代码执行的结果为:

***********列表排序的结果************
[1, 3, 5]
----------获取列表索引位置的值----------
1 5
**********添加元素以后的列表***********
[1, 2, 3, 5]

collections 中很多抽象类会为一些常见容器操作提供默认的实现， 这样一来你只需要实现那些你最感兴趣的方法即可。假设你的类继承自collections.MutableSequence ，如下：

import collections

class Item(collections.MutableSequence):
    def __init__(self, initial=None):
        self._item = initial if initial is not None else []

    def __getitem__(self, index):
        print('Getting:', index)
        return self._item[index]

    def __setitem__(self, index, value):
        print('Setting', index, value)
        self._item[index] = value

    def __delitem__(self, index):
        print('Deleting:', index)
        del self._item[index]

    def insert(self, index, value):
        print('Inserting:', index, value)
        self._item.insert(index, value)

    def __len__(self):
        return len(self._item)

a = Item([1, 2, 3, 4, 5])
print('长度：', len(a))

a.append(10)
a.append(2)
print(list(a))
print('2在a列表中出现的次数:', a.count(2))
a.remove(10)
print('删除列表中元素为10：', list(a))

以上代码执行的结果为:

长度： 5
Inserting: 5 10
Inserting: 6 2
Getting: 0
Getting: 1
Getting: 2
Getting: 3
Getting: 4
Getting: 5
Getting: 6
Getting: 7
[1, 2, 3, 4, 5, 10, 2]
Getting: 0
Getting: 1
Getting: 2
Getting: 3
Getting: 4
Getting: 5
Getting: 6
Getting: 7
2在a列表中出现的次数: 2
Getting: 0
Getting: 1
Getting: 2
Getting: 3
Getting: 4
Getting: 5
Deleting: 5
Getting: 0
Getting: 1
Getting: 2
Getting: 3
Getting: 4
Getting: 5
Getting: 6
删除列表中元素为10： [1, 2, 3, 4, 5, 2]

属性的代理访问

问题：

　　你想将某个实例的属性访问代理到内部另一个实例中去，目的可能是作为继承的一个替代方法或者实现代理模式

解决方案：

　　简单来说，代理是一种编程模式，它将某个操作转移给另外一个对象来实现。最简单的形式可能是像下面这样：

class A:
    def spam(self, x):
        self._x = x

    def foo(self):
        pass


class B1:
    '''简单代理'''
    def __init__(self):
        self._a = A()

    def spam(self, x):
        return self._a.spam(x)

    def foo(self):
        return self._a.foo()

    def bar(self):
        pass


#如果有大量的方法需要代理，那么使用getattr () 方法或许或更好些
class B2:
    def __init__(self):
        self._a = A()

    def bar(self):
        pass

    def __getattr__(self, name):
        return getattr(self._a, name)

另外一个代理例子是实现代理模式，例如：

#简单的实现代理模式
class Proxy:
    def __init__(self, obj):
        self._obj = obj

    def __getattr__(self, name):
        print('getattr:', name)
        return getattr(self._obj, name)

    def __setattr__(self, name, value):
        if name.startswith('_'):
            super().__setattr__(name, value)
        else:
            print('setattr:', name, value)
            setattr(self._obj, name, value)

    def __delattr__(self, name):
        if name.startswith('_'):
            super().__delattr__(name)
        else:
            print('delattr:', name)
            delattr(self._obj, name)


class Spam:
    def __init__(self, x):
        self.x = x

    def bar(self, y):
        print('Spam.bar:', self.x, y)


#实例化Spam
s = Spam(2)
#实例化Proxy，并把实例化的Spam传入进去
p = Proxy(s)
#调用Proxy中的getattr
print(p.x)
#调用Proxy中的bar方法
p.bar(3)
#切换x值
p.x = 30
print(p.x)

以上代码执行的结果为:

getattr: x
2
getattr: bar
Spam.bar: 2 3
setattr: x 30
getattr: x
30

在类中定义多个构造器

问题：

　　你想实现一个类，除了使用init () 方法外，还有其他方式可以初始化它

解决方案：

　　为了实现多个构造器，你需要使用到类方法。例如：

import time


class Date:
    '''
    方法一：使用类方法
    '''
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def today(cls):
        t = time.localtime()
        return cls(t.tm_year, t.tm_mon, t.tm_mday)



class NewDate(Date):
    pass

a = Date(2017, 8, 8)
b = Date.today()
c = NewDate.today()     #创建并返回最终的实例

创建不调用init 方法的实例

 问题：

　　你想创建一个实例，但是希望绕过执行init () 方法

解决方案：

　　可以通过new () 方法创建一个未初始化的实例。例如考虑如下这个类：

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

d = Date(2017, 8, 8)
print('可以使用init来初始化的:', d.year)

'''
d1 = Date.__new__(Date)
print(d1.day)
#会报这个错误 AttributeError: 'Date' object has no attribute 'day'
'''
#解决方法如下.这个Date day 还不存在，所以你需要手动初始化
data = {'year':2017, 'month':8 , 'day':8}
d1 = Date.__new__(Date)
for key,value in data.items():
    setattr(d1, key, value)

print('需要手动设置并初始化的(new):', d1.day)

以上代码执行的结果为:

可以使用init来初始化的: 2017
需要手动设置并初始化的(new): 8

当我们在反序列对象或者实现某个类方法构造函数时需要绕过init () 方法来创建对象。例如，对于上面的Date 来来讲，有时候你可能会像下面这样定义一个新的构造函数today() ：

from time import localtime

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def today(cls):
        d = cls.__new__(cls)
        t = localtime()
        d.year = t.tm_year
        d.month = t.tm_mon
        d.day = t.tm_mday
        return d

d = Date(2017, 8, 8)

让类支持比较操作

问题：

　　你想让某个类的实例支持标准的比较运算(比如>=,!=,<=,< 等)，但是又不想去实现那一大丢的特殊方法

解决方案：

　　装饰器functools.total ordering 就是用来简化这个处理的。使用它来装饰一个来，你只需定义一个eq () 方法，外加其他方法( lt , le , gt , or ge ) 中的一个即可。然后装饰器会自动为你填充其它比较方法

　　作为例子，我们构建一些房子，然后给它们增加一些房间，最后通过房子大小来比较它们：

from  functools import total_ordering


class Room:
    def __init__(self, name, length, width):
        self.name = name
        self.length = length
        self.width = width
        self.square_feet = self.length * self.width


@total_ordering
class House:
    def __init__(self, name, style):
        self.name = name
        self.style = style
        self.rooms = list()

    @property
    def living_space_footage(self):
        return sum(r.square_feet for r in self.rooms)

    def add_room(self, room):
        self.rooms.append(room)

    def __str__(self):
        '{}: {} square foot {}'.format(self.name,
                                       self.living_space_footage,
                                       self.style)

    def __eq__(self, other):
        return self.living_space_footage == other.living_space_footage

    def __lt__(self, other):
        return self.living_space_footage < other.living_space_footage

    def __gt__(self, other):
        return self.living_space_footage > other.living_space_footage


h1 = House('h1', 'Cape')
h1.add_room(Room('Master Bedroom', 14, 21))
h1.add_room(Room('Living Room', 18, 20))
h1.add_room(Room('Kitchen', 12, 16))
h1.add_room(Room('Office', 12, 12))
h2 = House('h2', 'Ranch')
h2.add_room(Room('Master Bedroom', 14, 21))
h2.add_room(Room('Living Room', 18, 20))
h2.add_room(Room('Kitchen', 12, 16))
h3 = House('h3', 'Split')
h3.add_room(Room('Master Bedroom', 14, 21))
h3.add_room(Room('Living Room', 18, 20))
h3.add_room(Room('Office', 12, 16))
h3.add_room(Room('Kitchen', 15, 17))

houses = [h1, h2, h3]

print('Is h1 bigger than h2?', h1 > h2) # prints True
print('Is h2 smaller than h3?', h2 < h3) # prints True
print('Is h2 greater than or equal to h1?', h2 >= h1) # Prints False
#print('Which one is biggest?', max(houses)) # Prints 'h3: 1101-square-foot Split'
#print('Which is smallest?', min(houses)) # Prints 'h2: 846-square-foot Ranch

 以上代码执行的结果为:

Is h1 bigger than h2? True
Is h2 smaller than h3? True
Is h2 greater than or equal to h1? False