一入python深似海，从此妹纸是路人（九）

一、单例模式

单例：这个类只能创建一个实例

单例模式：主要目的是确保某一个类只有一个实例存在。 ----不论实例化多少次，都只创建一个对象

class A:
    pass
a = A()
b = A()
print(id(a))
print(id(b))
输出：2317451431888
      2317451431840

实现单例 ----不论实例化多少次，都只创建一个对象

思路：

1.判断对象存不存在

2.如果对象不存在，则创建对象

3.如果对象存在，则引用对象

1.__new__()

class K():
    ins = None
    def __new__(cls, *args, **kwargs):
        if cls.ins is None:   # 不存在则创建
           cls.ins =  object.__new__(cls)   # 创建对象
           return cls.ins
        else:  # 对象存在时
            return cls.ins
k1 = K()
k2 = K()
print(id(k1))
print(id(k2))
输出：2312549691296
      2312549691296

2.hasattr() 判断对象是否包含对应的属性或方法；

实现单例

class A:
    b = 88
    def test(self):
        print('这是test')
a = A()
print(hasattr(a, 'b'))  # True
print(hasattr(a, 'test'))  # True

class A:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'ins'):
            cls.ins = super().__new__(cls)
        return cls.ins
a = A()
b = A()
print(id(a))
print(id(b))
输出：1993359494928
      1993359494928

二、魔法方法

dir() 查看所有的属性和方法

class A:
    pass
print(dir(A))

__doc__ 获取到注释内容

class A: """这是类的注释""" def funa(self): pass print(A.__doc__) 输出：这是类的注释

2.__module__和__class__

模块 --- 包 --- 库

导入模块

import random
from random import randint
from b import A
a = A()
print(a.__module__)   # b 输出的是模块名
print(a.__class__)    # <class 'b.A'>  输出类名

3.__call__() 允许一个类的实例像函数一样被调用

class A:
    def __init__(self):
        print('init')
    def __call__(self, *args, **kwargs):
        print('这是call')
a1 = A()    # 实例化一个对象
# a1.__call__()    # 对象名.方法名()
a1()

__dict__ :查看属性或方法

class A:
    mind = '呵呵'
    def __init__(self,name):
        self.name = name
    def func(self):
        print(123)
print(A.__dict__)

三、装饰器

装饰器：给函数添加额外的功能;

用装饰器的好处：做了封装，代码可以不变，可以不断复用;

装饰器的本质是闭包;

装饰器精髓处：它把真正要执行的业务函数作为参数，传入到装饰器中

装饰器 ---- 执行装饰器即在执行业务函数的基础上再添加额外功能

法一：

def outerf(func):   # func为真正要执行的业务函数的形参
    def innerf():
        res = func()      #  执行业务函数
        print('支付完成')   # 添加的额外功能
        return res
    return innerf

真正要执行的业务函数

def f1():
    print('这是一个支付功能')

t = outerf(f1)
t()

法二： @ 语法糖

def outerf(func):   # func为真正要执行的业务函数的形参
    def innerf():
        res = func()      #  执行业务函数
        print('支付完成')   # 添加的额外功能
        return res
        return innerf

# # 真正要执行的业务函数

@outerf
def f1():
    print('这是一个支付功能')
# 调用：和原来函数一样
f1()

为什么要使用装饰器

def outerf(func):   # func为真正要执行的业务函数的形参
    def innerf():
        res = func()      #  执行业务函数
        print('支付完成')   # 添加的额外功能
        return res
    return innerf

真正要执行的业务函数

@outerf
def f1():
    print('这是一个支付宝的支付功能')
@outerf
def f2():
    print('这是一个微信的支付功能')
f1()
f2()

内置装饰器

1） 静态方法 staticmethod() 相当于放在类里的纯函数

# # 不需要访问实例属性或方法 也不需要访问类属性或方法时可以设置为静态方法

class Cat():
    # def jiao(self):
    #     print('喵喵叫')
    @staticmethod
    def jiao():
        print('喵喵叫')
cat = Cat()
cat.jiao()

2） 类方法 classmethod()让类名能像实例对象一样调用类中的方法和属性

# class Person:
#     @classmethod
#     def human(cls):
#         cls.year = 5000
#         print(f'人类进化了{cls.year}年')
# # p = Person()
# # p.human()
# Person.human()

3)@property 属性

class A:
def f1(self):
        print(123)
    @property
    def f2(self):
        print(456)
        return 'haha'
a = A()
# # a.f1()
t = a.f2    # 通过获取属性的方式来调用
print(t)