Python-类、单例模式

类

基础术语

• 使用 类名() 创建对象，**创建对象 **的动作有两步
  • 在内存中为对象 分配空间
  • 调用初始化方法 init 为对象初始化
• 对象创建后，内存中就有了一个对象的** 实例**
• 通常会把
  • 创建出来的 对象 叫做 类 的实例
  • 创建对象的 **动作 **叫做 实例化
  • 对象的属性 叫做** 实例属性**
• 在程序执行时
  • 对象各自拥有自己的 实例属性
  • 调用对象方法，可以通过 self. 访问自己的属性或方法
• 每一个对象 都有一个自己独立的内存空间，互不干涉
• 多个对象的方法， 在内存中只有一份 ，在调用方法时，需要把对象的引用传递到方法内部

类是一个特殊的对象

• Python 中 一切皆对象
• 类是一个特殊的对象，同样会被加载到内存中，类对象在内存中只有一份
• 一个类可以创建出多个对象实例
• 除了封装** 实例 的属性和方法**外，类对象还可以拥有自己的属性和方法
• 通过** 类名.** 的方式可以访问类的属性和方法

示例

class Animal:
  # 定义一个 类 属性
  count=0


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


    Animal.count=Animal.count+1


animal1=Animal("小白")
animal2=Animal("小黑")
animal3=Animal("小绿")


print("查看类属性的变化次数:%d" %Animal.count)

输出结果

类方法

• **类方法 就是针对 类对象 **定义的方法
  • 在类方法 内部可以直接访问 类属性 或者调用其他的 类方法
• 类方法需要用** 修饰器 @classmethod **来标识，告诉解释器这是一个 类方法
• 类方法的 第一个参数 应该是 cls
  • 由 哪一个类调用的方法 ，方法内的 cls ，就是哪一个类的引用
  • 这个参数和 实例方法的第一个参数 self 类似
  • 不使用 cls ，使用其他名称也可以，习惯问题
• 通过 **类名. **调用类方法,不需要传递 cls 参数
• 在方法内部，可以通过** cls.** 访问类的属性或类的方法

**语法

**

@classmethod
def 类方法名(cls):
    pass

示例

class Animal:
  # 定义一个 类 属性
  count=0


  def __init__(self,name):
    self.name=name
    Animal.count=Animal.count+1


  # 定义一个 类 方法
  @classmethod
  def show_count(cls):
    print("我是类方法，类属性的值是：%d"%cls.count)


Animal("小白")
Animal("小黑")
# 调用类 方法
Animal.show_count()

输出结果

静态方法

• 使用修饰器 @staticmethod 来标识
• 通过 **类名. **调用 静态方法
• 使用场景
  • 不需要访问** 实例属性** 或者调用** 实例方法**
  • 不需要访问** 类属性** 或者调用 类方法

语法

@staticmethod
def 静态方法名():
    pass

示例

class Person:
  # 定义类属性
  count=0


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




  # 定义一个静态方法，静态方法不能调用 类方法或属性 与 实例方法或属性
  @staticmethod
  def static_test():
    print("我是一个静态方法，不能调用类方法与属性 和实例方法与属性")


# 静态方法直接用 类名调用
Person.static_test()

输出结果

综合练习示例

"""
需求：窗口取票
票数是共有的
每个人取的数量不一样


操作提示信息，不与任何属性或方法关联
"""
class Ticket:
  # 总共 10 张票
  totalTicket=10


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



  # 操作说明,可以使用静态方法实现
  @staticmethod
  def show_instructions():
    print("操作说明：取票的数量不能超过票总数量!!!")


  # 显示总票数，可以使用 类方法
  @classmethod
  def show_ticket(cls):
    print("还剩余的票数有:%s 张" %cls.totalTicket)


  # 取票，可以使用实例方法
  def take_ticket(self,num):
    Ticket.totalTicket=Ticket.totalTicket-num
    print("%s 取走了 %d 张票..."%(self.name,num))




# 取票的操作说明 
Ticket.show_instructions()


# 开始取票,张三 取3张， 李四取4张
zs=Ticket("张三")
zs.take_ticket(3)
#查看剩余票数
Ticket.show_ticket()




ls=Ticket("李四")
ls.take_ticket(4)
#查看剩余票数
Ticket.show_ticket()

输出结果

单例模式

设计模式

• **设计模式 **是针对某一特定问题的解决方案，由人们总结和提炼的
• 使用设计模式 是为了可重用代码， 使代码更容易理解，保证代码可靠性
• 单例设计模式
  • 目的： 让类创建的对象，在系统中只有 唯一一个
  • 每一次执行 **类名（） **返回的内存地址引用，都是同一个

**__new__方法

**

• 使用 类名（） 创建对象时， Python的解释器首先会调用** new **方法为对象 分配内存空间
• Python的解释器获得对象的引用后，将引用作为第一个参数，传递给 **init **方法
• 重写 new 方法的代码非常固定
• 重写 new 方法一定要 return super(). new (cls)
• 否则 Python的解释器 得不到对象引用，就不会调用初始化方法
• **new **是一个 静态方法 ，在调用时需要 主动传递 cls 参数

示例

class SingleClass():


  # 定义类实例对象
  instants=None


  # 重写 __new__ 方法
  def __new__(cls,*agrs,**kwargs):
    print("创建对象方法.....")

    if SingleClass.instants== None:
      # 初始化实例对象,调用父类方法
      SingleClass.instants=super().__new__(cls)
    return SingleClass.instants

  def __init__(self):
    print("初始化方法。。。。")


# 单例模式 ，不管创建多少次实例，实际上都是同一个
s1=SingleClass()
s2=SingleClass()
s3=SingleClass()
print(s1)
print(s2)
print(s3)

输出结果

以上的方法虽然解决了对象只会创建一次的问题，但是初始化的方法还会调用多次，消耗内存。 此处可以 增加一个 initFlag 的标记，一但初始化后就打上标记，以后就不再进行初始化。 改造代码如下：

class SingleClass():


  # 定义类实例对象
  instants=None


  # 定义一个初始化标记
  initFlag=False


  # 重写 __new__ 方法
  def __new__(cls,*agrs,**kwargs):    
    if SingleClass.instants== None:
      print("创建对象方法.....")
      # 初始化实例对象,调用父类方法
      SingleClass.instants=super().__new__(cls)
    return SingleClass.instants

  def __init__(self):


    if SingleClass.initFlag:
      return


    print("初始化方法。。。。")
    SingleClass.initFlag=True




# 单例模式 ，不管创建多少次实例，实际上都是同一个
s1=SingleClass()
s2=SingleClass()
s3=SingleClass()
print(s1)
print(s2)
print(s3)

**输出结果

**