面向对象编程进阶2之魔术方法

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

本文主要介绍对象的方法

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、_inint_方法的补充

class Person:
    name = '张三'

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

    def eat(self, food):
        print('{}正在吃{}！。。。'.format(self.name, food))

    def run(self):
        print('{},今年{}岁，正在跑步'.format(self.name, self.age))


p = Person('李四', 20)
p.name = 'lisi'
p.eat('红烧肉')
p.run()

p1 = Person('wangwu', 22)
p1.name = '王五'
p1.eat('狮子头')
p1.run()

p2 = Person('zhaoliu', 17)
p2.run()


# eat()

二、小花猫的应用案例

# 猫
class Cat:
    type = '猫'

    # 通过__init__初始化的特征
    def __init__(self, nickname, age, color):
        self.nickname = nickname
        self.age = age
        self.color = color

    # 动作：方法
    def eat(self, food):
        print('{}喜欢吃{}'.format(self.nickname, food))

    def catch_mouse(self, color, weight):
        print('{},抓了一只{}kg的，{}的大老鼠！'.format(self.nickname, weight, color))

    def sleep(self, hour):
        if hour < 5:
            print('乖乖！继续睡觉吧！')
        else:
            print('赶快起床出去抓老鼠！')

    def show(self):
        print('猫的详细信息:')
        print(self.nickname, self.age, self.color)


# 创建对象
cat1 = Cat('花花', 2, '灰色')

# 通过对象调用方法
cat1.catch_mouse('黑色', 2)

cat1.sleep(8)

cat1.eat('小金鱼')

cat1.show()

三 类方法的使用

# 类方法

'''
    特点:
    1.定义 需要依赖装饰器@classmethond
    2. 类方法中的参数不是一个对象
    3. 类方法中只可以使用类属性
    4.类方法中是否能够使用普通方法? 不能

类方法作用:
    因为只能访问类属性和类方法，所以可以在对象创建之前，如果需要完成一些动作(功能)


'''
class Dog:
    def __init__(self,nickname):
        self.nickname=nickname

    def run(self): #self 对象
        print('{}在院子里跑来跑去!'.format(self))

    @classmethod
    def test(cls): #cls class
        print('---------')
        print(cls) #<class '__main__.Dog'>
       # print(cls.nickname) 报错
        #print(self.nickname) 报错
    def eat(self):
        print('吃放.....')
        self.run()  #类中方法的调用，需要通过self.方法名()

#调用类方法
Dog.test()
# d=Dog('大黄')
#
# d.run()#调用
# d.test()

四 静态方法

# 补充类方法

class Person:
    __age=18
    def __init__(self,name):
        self.name=name
    def show(self):
        print('------>',Person.age)

    @classmethod
    def update_age(cls):
        cls.__age=20
        print('----------->类方法')
    @classmethod(cls):
    def show_age(cls):
        print('修改后的年龄是',cls.show_age())
    @staticmethod
    def test():
        print('---------->静态方法')
        # print(self.name) 报错
        print(Person.__age)


#p=Person()
#p.show()
person.age=p.age+1
Person.update_age()
Person.show_age()
print(Person.age)
# p=age=p.age+1
# p.show()

'''
静态方法：很类似类方法
1.需要装饰器@staticmethod
2.静态方法是无需传递参数(cls,self)
3.也只能访问类的属性和方法,对象的是无法访问的
4.加载时机同类方法
总结:
类方法 静态方法
不同:
 1.装饰器不同
 2.类方法是由参数的，静态方法没有参数
相同:
    1.只能访问类的属性和方法，对象是无法访问的
    2.都可以通过类名调用访问
    3.都可以在创建对象之前使用，因为是不依赖于对象
普通方法 与 两者区别:
不同:
    1.没有装饰器
    2.普通方法永远是要依赖对象，因为每隔普通方法都有一个self
    3.只有创建了对象才可以调用普通方法，否则无法调用
'''

Person.test()

五 _new_方法和_call_方法

#魔术方法
#__init__:初始化魔术方法
# 触发时机，初始化对象时触发(不是实例化触发，但是和实例化在一个操作）

#__new__: 实例化的魔术方法
#触发时机: 在实例化对时触发

#__call__: 对象调用方法
#触发时机:将对象当成函数使用的时候，会默认调用此函数中的内容

#__del__: delete的缩写析构魔术方法
#触发时机,当对象没有用(没有任何变量引用)的时候被触发
class Person:
    def __init__(self,name):
        print('---------->init',self)
        self.naem=name
    def __new__(cls, *args, **kwargs): #__new___向内存申请空间--->地址
        print('-------->new')
        postion=object.__new__(cls)#0x637843784
        print(postion)
        return postion #地址
    def __call__(self, name):
        print('-------->call')
        print('执行对象得到参数是',name)

p=Person('aa')
#需要把对象当做函数使用可以使用__call__
p('hello')
print(p)

六 魔术方法之__del__方法

import sys
'''
__del__
 1.对象赋值
    p=Person()
    p1=p
     说明:p和p1共同指向一个地址

2. 删除地址的引用
    del p1 删除p1对地址的引用
3.查看对地址的引用
    import sys
    sys.getrefcount()
4. 当一块空间没有了任何引用,默认执行__del__
        ref=0
'''

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

    def __del__(self):
         print('----del----')
p=Person('jack')
p1=p
print(p1.name)
p2=p
print(p2.name)

del p2
print('删除p2后打印',p.name)

del p1
print('删除p1后打印',p.name)
#
# del p
# print('删除p后打印',p.name)
# print(sys.getrefcount(p))
#对象赋值
n=5
n1=n

七 魔术方法之__str__

# __str__:
#触发时机: 打印对象名 自动触发去调用__str__里面的内容
#注意: 一定要在__str___方法中添加return ,return后面的内容。



class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        return '姓名是:' +self.name

p=Person('tom',18)
print(p)

#单纯打印对象名称。出来的是一个地址。地址对于开发者来说没有太大意义

# 如果想在打印对象名的时候能够给开发者更多一些信息量。

p1=Person('lili',20)
print(p1)

'''
总结:魔术方法
重点:
__init__ (构造方法，创建完空间之后调用的第一个方法)  __str__

了解:
__new__ 作用 开辟空间

__del__ 作用 没有指针引用的时候会调用，99%都不需要重写

__call__ 作用: 想不想将对象当成函数用。


大总结:
方法:
    普通方法-  ---->> 重点
    def 方法名(self,[参数]):
        方法体
    对象.方法()
    
    方法之间的调用:
    class A:
        def a(self):
            pass
        def b(self):
            #调用方法a
    
    类方法:
    @classmethond
    def 方法名(cls,[参数]):
        pass
    类名.方法名()
    对象.方法名()
    
    魔术方法:
        自动执行方法
        print(p)  ---->__str__
'''

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。