Python的类初始化方法

python 专栏收录该内容
26 篇文章 0 订阅

摘自Mastering Object-oriented Python

隐式的基类——object

Python是面向对象程序设计语言,有一个类似root的基础类object类。任何自定义的类,都会隐式继承object。

class X:
    pass

print(X.__class__)
# <class 'type'>
print(X.__class__.__base__)
# <class 'object'>

基类中的初始化方法

  • 延迟赋值

这是指先创建类模板,然后在实例中定义属性并赋值。在Python中,延迟赋值的合法的,但是会存在潜在问题,因此要尽量避免这样的用法。

在基类中实现__init__()方法

每当创建一个对象,Python会先创建一个空对象,然后调用该对象的__init__()函数。

一个常见的多态设计

class Card:
    def __init__(self,rank,suit):
        self.suit = suit
        self.rank = rank
        self.hard, self.soft = self._points()

class NumberCard(Card):
    def _points(self):
        return int(self.rank), int(self.rank)

class AceCard(Card):
    def _points(self):
        return 1, 11

class FaceCard(Card):
    def _points(self):
        return 10, 10

使用__init__()方法创建常量清单

可以把创建好的花色对象做缓存,构建一个常量池,使得在调用时对象可被重用,那么性能将得到显著的提升。

class Suit:
    def __init__(self, name, symbol):
        self.name = name
        self.symbol = symbol

Club, Diamond, Heart, Spade = Suit('Club','♠'), Suit('Diamond','♦'), Suit('Heart','♥'), Suit('Spade','♣')

Cards = [AceCard('A', Spade), NumberCard('2',Spade), NumberCard('3',Spade)]

使用工厂函数调用__init__()

可以使用工厂函数来完成所有的Card对象的创建。在Python中实现工厂有两种途径

  • 定义一个函数,返回不同类的对象
  • 定义一个类,包括了创建对象的方法

一个用来生成Card子类对象的工厂函数例子

def card(rank, suit):
    if rank == 1: return AceCard('A',suit)
    elif 2 <= rank < 11: return NumberCard(str(rank),suit)
    elif 11 <= rank < 14:
        name = {11: 'J', 12: 'Q', 13: 'K'}[rank]
        return FaceCard(name, suit)
    else:
        raise Exception('Rank out of range.')

deck = [card(rank,suit) for rank in range(1,14)
        for suit in (Club, Diamond, Heart, Spade)]

这里需要注意的是if语句的结构,else语句没有做一些其他步骤,而只是单纯地抛出了一个异常。像这样的catch-all else语句的使用方式是有争议的。

使用elif简化设计来获得一致性

工厂方法card()中包括了两个很常见的结构

  • if-elif序列
  • 映射

这是一个没有使用映射Card工厂类的例子

def card3(rank, suit):
    if rank == 1: return AceCard('A',suit)
    elif 2 <= rank < 11: return NumberCard(str(rank),suit)
    elif rank == 11: return FaceCard('J', suit)
    elif rank == 12: return FaceCard('Q', suit)
    elif rank == 13: return FaceCard('K', suit)
    else:
        raise Exception('Rank out of range.')

相比上一个版本,这个函数在实现上获得了更好的一致性。

使用映射和类来简化设计

下面这个例子用映射来实现,把rank映射为对象,然后又把rank值和suit值作为参数传入Card构造函数来创建Card实例。

def card4(rank, suit):
    class_ = {1: AceCard, 11: FaceCard, 12: FaceCard, 13: FaceCard}.get(rank, NumberCard)
    return class_(rank, suit)

实现两部分映射

  • 并行映射
    不推荐使用

  • 映射到一个牌面值的元组

def card5(rank, suit):
    class_, rank_str = {1: (AceCard,'A'),
                        11: (FaceCard,'J'),
                        12: (FaceCard,'Q'),
                        13: (FaceCard,'K')}.get(rank,(NumberCard,str(rank)))
    return class_(rank_str, suit)
  • partial函数设计

partial()函数在面向对象编程中不是很常用。

  • 工厂模式的流畅API设计
class CardFactory:
    def rank(self, rank):
        self.class_, self.rank_str = {1: (AceCard,'A'),
                                      11: (FaceCard,'J'),
                                      12: (FaceCard,'Q'),
                                      13: (FaceCard,'K')}.get(rank,(NumberCard,str(rank)))
        return self

    def suit(self, suit):
        return self.class_(self.rank_str, suit)

card8 = CardFactory()
deck8 = [card8.rank(r+1).suit(s) for r in range(13)
         for s in (Club, Diamond, Heart, Spade)]

这种方法并没有利用__init__()在Card类层次结构中的作用,改变的是调用者创建对象的方式。

在每个子类中实现__init__()方法

class Card:
    def __init__(self, rank, suit, hard, soft):
        self.suit = suit
        self.rank = rank
        self.hard = hard
        self.soft = soft

class NumberCard(Card):
    def __init__(self, rank, suit):
        super().__init__(str(rank), suit, rank, rank)

class AceCard(Card):
    def __init__(self, rank, suit):
        super().__init__('A', suit, 1, 11)

class FaceCard(Card):
    def __init__(self, rank, suit):
        super().__init__({11: 'J', 12: 'Q', 13: 'K'}[rank], suit, 10, 10)

使用__init__()方法和工厂函数之间存在一些权衡。通常直接调用比“程序员友好”的__init__()函数并把复杂性分发给工厂函数更好。

简单的组合对象

一个组合对象也可以称作容器

设计集合类,通常有如下3种策略:

  • 封装
  • 扩展
  • 创建

封装集合类

定义Deck类,内部实际调用的是list对象。Deck类的pop()方法只是对list对象响应函数的调用。

class Deck:
    def __init__(self):
        self._cards = [card8.rank(r+1).suit(s) for r in range(13)
                       for s in (Club, Diamond, Heart, Spade)]
        random.shuffle(self._cards)

    def pop(self):
        return self._cards.pop()

扩展集合类

pop()函数只需继承自list集合就可以很好地工作,其他函数也一样。

class Deck2(list):
    def __init__(self):
        super().__init__(card8.rank(r+1).suit(s) for r in range(13) for s in (Club, Diamond, Heart, Spade))
        random.shuffle(self)

完成组合对象的初始化

__init__()初始化方法应当返回一个完整的对象,这是理想的情况。

不带__init__()方法的无状态对象

对于策略模式的对象来说这是常见的设计。一个策略对象以插件的形式符合在主对象上来完成一种算法或逻辑,例如GameStrategy类。



作者:plutoese
链接:https://www.jianshu.com/p/a5cb4070e733
來源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值