基于linux下python学习（类属性、类结构、设计模式）

一、类结构

类的结构
实例
1、使用面向对象开发，第一步是设计类
2、使用 类名（）创建对象，创建对象的动作有两步
  （1）在内存中为对象分配空间
  （2）调用初始化方法 __init__为对象初始化
3、对象创建后，内存中就有了一个对象的实实在在的存在实例

因此：
1、创建出来的对象叫做类的实例
2、创建对象的动作叫做实例化
3、对象的属性叫做实例属性
4、对象调用的方法叫做实例方法

在程序执行时：

1、对象各自拥有自己的实例属性

2、调用对象的方法，可以通过self

  访问自己的属性

  调用自己的方法

结论：
1、每一个对象都有自己独立的内存空间，保存各自不同的属性
2、多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用
传递到方法内部

"""
class Tool(object):
# 1、使用了赋值语句定义类属性，记录所有的工具数量
    count = 0
    def __init__(self,name):
        self.name = name
# 2、让属性值+1
        Tool.count +=1

# 创建工具对象（对象在创建的时候，会自动调用初始化方法）
tool1 = Tool ('A')
tool2 = Tool ('B')
tool3 = Tool ('c')
# 输出工具对象的总数，使用 【类名.属性名】来获取
print Tool.count

二、类属性

1、类属性就是针对类对象定义的属性
使用赋值语句在class关键字下方可以定义类属性
类属性用于记录与这个类相关的特性
类方法就是针对类对象定义的方法
在类方法内部就可以直接访问类属性或者调用其他类方法

语法如下：
@classmethod
def 类方法（cls）
  pass

"""
class Toy(object):
    # 1、定义类属性，记录所有的工具数量
    count = 0
    @classmethod      #类方法
    def show_toy_count(cls):
    # cls.coun:在类方法的内部访问当前的类属性
        print '玩具对象的数量 %d' % cls.count
    def __init__(self,name):
        self.name = name
        Toy.count += 1
# 创建玩具对象
toy1 = Toy('11')
toy2 = Toy('22')
toy3 = Toy('33')
# 调用类方法
Toy.show_toy_count()
# 在方法的内部，可以直接访问类属性

2、

静态方法
在开发时，如果需要在类中封装一个方法，这个方法：
既不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
这个时候可以把这个方法封装成一个静态方法
语法如下：
@staticmethod
def 静态方法（）：
    pass
静态方法需要修饰器@staticmethod来标识，告诉解释器
这是一个静态方法，通过类名，调用静态方法
"""
class Cat(object):
    @staticmethod
    # 静态方法不需要传递第一个参数：self
    def call():
        print '小猫喵喵叫'
# 通过类名，调用静态方法
#不需要创建对象，直接可以使用
Cat.call()

3、

1、设计一个Game类
2、属性
    （类属性），记录游戏的历史最高分（与这个游戏类有关系，与每次游戏无关）
    （实例属性),记录当前游戏玩家的玩家姓名
3、方法
    （静态方法）：方法show_help显示游戏帮助信息
    （类方法）：方法show_top_score显示历史最高分
    （实例方法）：方法start_game开始当前玩家的游戏
4、主程序步骤：
    1、查看帮助
    2、查看历史最高分
    3、创建游戏对象，开始游戏
"""
class Game(object):
    top_score = 0
    @classmethod
    def show_top_score(cls):
        print ' 得分%d'  % cls.top_score
    def __init__(self, name):
        self.name = name
        Game.top_score += 1
    @staticmethod
    def show_help():
        print '游戏帮助'
    def start_game(self):
        print '%s 开始游戏了' % self.name

Game.show_help()
Game.show_top_score()
xiaopang = Game('小胖')
xiaopang.start_game()

"""
案例小结：

"""

1、实例方法：方法内部需要访问实例属性

2、类方法：方法内部只需要访问类属性

3、静态方法：方法内部不需要访问实例属性和类属性

三、设计模式

1、使用类名（）创建对象时，python的解释器首先会调用__new__方法
为对象分配空间__new__是一个由object基类提供的内置的静态方法，主要
有两个作用：在内存中为对象分配空间，返回对象的引用
python的解释器获得对象的引用后，将引用作为第一个参数，传递给 __init__
方法，__new__:负责给对象分配空间 __init__(初始化方法）负责给对象初始化

单例：让类创建的对象，在系统中只有唯一的一个实例

1、

class Cat():
    def __init__(self,name):
        self.name = name
    def call(self):
        print '喵喵'
cat1 = Cat('aa')
print cat1
cat1.call()
cat2 = Cat('bb')
print cat2
cat2.call()

2、

def test(**kwargs):
    for key in kwargs:
        print '%s: %s'  %(key,kwargs[key])
test(arg2='two',arg3=3)

3、只执行一次初始化工作，在每次使用类名（）创建对象时，python的解释器都会自动调用两个方法

   __new__分配空间

  __init__对象初始化

但是在上一小节中 __new__方法改造之后，每次都会得到第一次被创建对象的引用，但是初始化方法

还会被再次使用

需求：让初始化方法只执行一次

class  MusicPlayer(object):
    instance = None
    init_flag = False
    def __new__(cls, *args, **kwargs):
# 第一个参数cls：哪一个类调用就传递哪一个类
# 第二个参数*args:多值参数
# 第三个参数 **kwargs:多值的字典参数
# 创建对象的时候，new方法会被自动调用
# 重写了父类的方法
        if cls.instance is None:
            cls.instance = object.__new__(cls)
        return cls.instance
    def __init__(self):
          if MusicPlayer.init_flag:
              return
          print '初始化播放器'
          MusicPlayer.init_flag = True
player1 = MusicPlayer()
print player1

player2 = MusicPlayer()
print  player2