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)

输出结果

程序猿与投资生活实录已改名为  程序猿知秋，WX同款，欢迎关注！