py 面向对象

'''
面向对象：

'''
# 所有的类名首字母大写，多个单词使用驼峰命名
# 所有的 类 继承了object
'''
class 类名[(父类)]:
    属性： 特征
    
    方法: 动作
'''


# class Phone:
#     brand = 'huawei'
#
#
# aa = Phone()
# print(aa.brand)
#
# bb = Phone()
# print(bb.brand)
# bb.brand = 'iphone'
# print(bb.brand)


# 定义类和属性
class Student:
    # 类属性
    name = 'xiaowei'
    age = 24


# 创建对象,先找自己空间的（不存在），再去找模型
xiaowei = Student()
xiaowei.age = 26
print(xiaowei.age)

# 类中的方法：动作
# 种类： 普通方法  类方法  静态方法  魔术方法
'''
普通方法格式
def 方法名(self):
    pass
'''


class Phone:
    brand = 'xiaomi'
    price = 9999
    type = 'mate 30'

    # Phone 类里面的方法
    def call(self):
        print('self:', self)
        print('正在打电话')
        print('留言：',self.note)


phone1 = Phone()
phone1.note = '我的通讯录1'
phone1.call()

print('#'*100)

#魔术方法
'''
1,找到一块空间叫Phone2
2,利用Phone2类，向内存申请一块Phone2 一样的空间
3，去Phone2中找有没有__init__()如果没有则执行将开辟的内存给对象名 p
4，如果有__init__()，则会进入init 方法执行完里面的动作，再将内存地址赋值给对象 P
'''
class Phone2:
    #魔术方法： __名字__()
    def __init__(self):   #init 初始化
        print('----------init')
        self.brand =  'xiaomi'
        self.price = 5000
    def call(self):
        print('----call')
        print('价格：',self.price)

p = Phone2()

print(p.price)



class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def cat(self):
        print(f'{self.name}正在吃臭豆腐')
    def run(self):
        print(f'{self.name}今年{self.age}岁了，正在跑步')

# name = input('请输入名字:')
# age = input('请输入你的年龄:')
# p = Person(name,age)
# p.cat()
# p.run()
# 请输入名字:sansan
# 请输入你的年龄:19
# sansan正在吃臭豆腐
# sansan今年19岁了，正在跑步



class  Cat:
    type = '猫'

    def __init__(self,nickname,age,color):
        self.nickname = nickname
        self.age = age
        self.color = color

    def cat(self,food):
        print(f'{self.nickname}喜欢吃{food}')

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

    def sleep(self,hour):
        if hour < 4:
            print('乖乖再睡下')
        else:
            print('赶快起来抓老鼠')

    def show(self):
        print('猫的详细信息如下')
        print(f'''
        {self.nickname}
        {self.age}
        {self.color}
        ''')
cat1 = Cat('花花',18,'白色')
cat1.show()
cat1.cat('小黑')

#类方法
'''
特点：
1，定义需要依赖装饰器#calssmethod
2,类方法中参数不是一个对象，而是类
   print(cls) #<class '__main__.Dog'>
3，类方法中中可以使用类属性
4，类方法是否可以使用普通方法？   不能

类方法作用
因为只能访问类属性和类方法，所以可以在对象之前，如果需要完成一些动作
'''
class Dog:
    def __init__(self,nickname):
        self.nickname = nickname

    def run(self):
        print(f'{self.nickname}在院子跑来跑去')

    def eat(self):
        print('aaaa')
        self.run()  # 类中的方法调用，需要通过self.方法名()

    @classmethod
    def test(cls):
        print(cls)

dog1 = Dog('小黄')
dog1.run()
dog1.test() #<class '__main__.Dog'>


class Person:
    __age = 18

    def __init__(self,name):
        self.anem = 'jack'

    def show(self):
        print('---->',Person.__age)

    @classmethod
    def update_age(cls):
        cls.__age = 20
        print('---------->类方法')

    @classmethod
    def show_age(cls):
        print('修改后的年龄是',cls.__age)

    @staticmethod
    def test():
        print('----------静态方法')
        print(Person.__age)
Person.update_age()
Person.show_age()
Person.test()
'''
静态方法：类似类方法
1，需要装饰器@staticmethod 
2，静态方法是无需传递参数（cls,self）
3,也只能访问类的属性和方法，对象是无法访问
4，加载时机同类方法

总结：
类方法： 静态方法
不同：
    1，装饰器不同
    2，类方法是有参数的，静态方法没有参数
相同
    1，只能访问类的属性和方法，对象是无法访问的
    2，都可以通过类名调用访问
    3，都可以在创建对象之前使用，因为不是依赖对象

普通方法 与 两者的区别：
不同：
    1，没有装饰器
    2，普通方法永远是要依赖对象，因为每个普通方法都有一个self
    3,只有创建了对象才可以调用普通方法，否则无法调用
'''



# 魔术方法进阶
'''
重点 __init__   __str__

1, __init__
初始化魔术方法，
触发时机：初始化对象时触发
参数，至少有一个self,接收对象
返回值：无
作用：初始化对象成员
注意：使用该方式初始化的成员都是直接写入对象当中，类中无法具有

2, __str__
触发时机：打印对象名 自动触发调用__str__ 里面的内容
注意： 这个方法一定要添加 return   return后面的内容就是打印对象看到的内容

3， __new__
实例化魔术方法
触发时机： 在实例化时触发
参数：至少一个cls 接收当前类
返回值：必须返回一个对象实例
作用：实例化对象
注意：实例化对象是object 类底层实现，其他类继承object的__new__才能够实现实例化对象
没事别碰这个魔术方法，先触发__new__才会触发__init__

4, __del__;
1,对象赋值
    p = Persion()
    p1 = p
    说明：p 和 p1 共同指向一个地址
2，删除地址的引用
    del p1    删除p1 对地址的引用
3，查看 对地址的引用次数：
    import sys
    ys.getrefcount(p)
4,当一块空间没有了任何引用，默认执行 __del__
系统自带，不需要写
'''
import  sys
class Pet:
    def __init__(self,name):
        print('----------init')
        self.name = name

    # def __del__(self):
    #     print('---------del---')

p = Pet('jack')
p1 = p
p2 = p
print(p1.name)
print(p2.name)
print(sys.getrefcount(p))

del p1
print(sys.getrefcount(p))

print('--'*30)

class Per:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return print(f'姓名是{self.name}，年龄{self.age}')
        # return '姓名是:' + self.name + '年龄:' + str(self.age)

p1 = Per('tom',20)
print(p1)