python 类初始化赋值,Python的类初始化方法

摘自Mastering Object-oriented Python

隐式的基类——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类。

(未完待续)