不是一定要初始化啊。

def init()

是够造函数

你可以用

@classmethon

@staticmethod

进行修饰

隐式的基类——object

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

class X:

pass

print(X.__class__)

print(X.__class__.__base__)

基类中的初始化方法

延迟赋值
这是指先创建类模板，然后在实例中定义属性并赋值。在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
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。