Python类(二）：总结复习

继之前的类再补充一下知识点

魔术方法之__str__

先简单的说一说__str__的作用吧
  __str__方法是在使用print函数打印输出对象到屏幕时被调用的方法，用于返回对象的规范化字符串表现形式

举例

首先，我们要创建一个学生类(Students) 然后我可以调用一个方法返回显示对应学生的信息

#不用__str__
class Students:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def show(self):#定义返回方法
        return '姓名:{}  年龄:{}  性别:{}'.format(self.name,self.age,self.sex) 
zhaoliu = Students('赵六',29,'男')
show_Student = zhaoliu.show()
print(show_Student)
#可以看的出来有些麻烦，需要自己来调用show方法

#使用__str__方法
class Students:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __str__(self):
        return '姓名:{}  年龄:{}  性别:{}'.format(self.name,self.age,self.sex)
       	#返回到zhangsan这个变量中，由系统自己调用的__str__
       	#魔术方法都是自调用的
zhangsan = Proson('张三','男',20)
print(zhangsan)       
'''
可以看的出来使用__str__后，代码也少了，也不用繁琐的调用了
'''

但是需要注意的是__str__只能返回字符串哟!
class Student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __str__(self):
        return self.age
 s = Student('小明',20,'男')
 print(s)#则会报错,TypeError: __str__ returned non-string (type int)
 #所以__str__只能返回str类型的

   

方法调用方法

小明的一天
class One_day(object):
    def start(self):
        print('小明一天开始了')
        self.morning()
    def  morning(self):
        print('上午，小明和同学们在踢毽子/玩游戏')
        self.afternoon()
    def afternoon(self):
        print('下午，小明就开始写暑假作业了')
        self.night()
    def night(self):
        print('打起了王者荣耀，玩的老开心了')
a = One_day()
a.start()
'''
方法的互相调用使我们的代码量减少了(合理使用)
'''

封装（私有化）

封装的作用：
  封装操作可以对受访问保护的成员进行功能开放的控制，达到保护数据不被非法访问的目的 
定义格式:
  self.__属性名 = 值

实例：

#李四发现自己写的东西，外面很容易就访问到了
class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
l = People('李四',74,'男')
print(l.name)
print(l.age)
print(l.sex)
#于是他进行了私有化封装
class People:
    def __init__(self,name,age,sex):
        self.__name = name#他先对name进行了私有化操作
        self.age = age
        self.sex = sex
l = People('李四',74,'男')
print(l.__name)#但是这样做，使得他无法访问__name了
print(l.age)
print(l.sex)

#于是他又进行了学习，发现只要在函数内获取和修改就可以了
class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def get_name(self):
        return self.__name
    def set_name(self,name):
    	#我们可以在这里做一些验证操作...
        self.__name = name         
l = People('李四',74,'男')
name = l.get_name()
print(name)#这样即可
print(l.age)
print(l.sex)
l.set_name('张三')	
print(dir(People))#我们可以看到的，其实Python的私有化并不是真正的私有化，只是进行了伪装
print(l._People__name)#对象._类__私有化属性  一样可以访问的到

私有化之@property

class People:
    def __init__(self,name,age,sex):
        self.__name = name
        self.age = age
        self.sex = sex
    @property
    def get_name(self):
        return '他叫{}'.format(self.__name)
    @get_name.setter#方法名.setter
    def set_name(self,name):
        if not isinstance(name,str):
            print('必须是str类型')
        else:
            print('之前的name是{} 修改后的name是{}'.format(self.__name,name))
            self.__name = name
a = People('小明',20,'男')
d = a.get_name#调用方法变了
a.set_name = '小李'#修改方法也变了，没有括号了

@classmethod类方法
类方法就是针对类属性而定义的

class People(object):
    color = 'Blue'#类属性
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def show(self):
        print(People.color)
        People.color = 'Red'
    @classmethod
    def get_color(cls,s):
        print('现在的颜色:',cls.color)
        cls.color = s

a = People('小李',20,'男')
a.show()
print('People颜色是:',People.color)
a.color = 'yellow'
print('a对象颜色是:',a.color)
print('People颜色是:',People.color)
a.get_color('pp')
a.show()
print(People.color)

大致流程

__del__方法

销毁我们类创建的对象:
直接上代码吧！

import  sys#导入sys模块
class Person_:
    def __init__(self):
        print('----start')
    def __del__(self):
        print('销毁中.....')
a = Person_()
b = a
c = a
print(sys.getrefcount(a)-1)#3
#这段话是查看有多少个对象
#因为使用sys.getrefcount()的时候加了1所以减一
del c
del b
del a

有趣的是只要我们有类，并且有魔术方法__del__就会在类结束的时候自调用
class People:
    def __init__(self):
        self.name = '李四'
        self.age = 13

    def __del__(self):
        print('销毁中....')

a = People()

print('aa')#在这里我们并没有销毁对象
#但是奇怪的是，但我们执行完毕了后也会显示  销毁中....
#因为执行完毕后，空间就被回收了，所以就会这样

再推推
class People:
    def __init__(self):
        self.name = '赵六'
        self.age = 19
    def __del__(self):
        print('销毁中....')

a  =  People()
del a
print('-------------------')
'''
执行结果:
销毁中....
------------------

当我们类没有对象的时候就会输出销毁中...
内存空间给回收了也一样
'''

单例

直接举例

在这里有三种实现单例的方法

#__new__方法
class People(object):
    _instance = None
    def __int__(self,name,age):
        self.name = name
        self.age = age
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = object.__new__(cls)
            return cls._instance
        return cls._instance
zhangsan = People('张三',20)
print(id(zhangsan))
lisi = People('李四',21)
print(id(lisi))


#使用类方法
class People:
    def __int__(self):
        print('init')

    @classmethod
    def Establish(cls,*args,**kwargs):#类方法调用本类
        print('类方法')
        if not hasattr(People,'_instance'):#判断是否存在
            cls._instance = People(*args,**kwargs)#创建_instance类
            return cls._instance#返回地址
        return cls._instance#返回地址
a = People()#这个并不是单例
b = a.Establish()#这个才是 只有调用Establish方法才会
l = People()
p = l.Establish()#这个也是
print(id(b),id(p))
#b和P的内存地址的一致的

#使用装饰器
def Singleton(cls):
    _instance = {}
    def sing(*args,**kwargs):
        print('_sing Go!')
        if cls not in _instance:
            _instance[cls] = cls(*args,**kwargs)
        return _instance[cls]
    return sing

@Singleton#使用装饰器
class A(object):
    def __init__(self):
        pass
o  = A()
h = A()
print(id(o),id(h))

先到这里了，谢谢大家（草率）