day25——私有成员、类方法、静态方法、属性、isinstance和issubclass的区别

day25

类的私有成员

当你遇到重要的数据，功能（只允许本类使用的一些方法，数据）设置成私有成员

python所有的私有成员都是纸老虎，形同虚设

类从加载时，只要遇到类中的私有成员，都会在私有成员前面加上(_类名)

class A:
    name = "李业"
    __name = "刚哥" # 私有类的属性

    def __func(self): # 私有类的方法
        print("in __func")
print(A.__dict__)
print(A._A__name)  # 可以获取到 李业

私有类的静态属性

• 类的内部可以访问

class A:

    name = '李业'
    __name = '钢哥'  # 私有类的属性

    def func(self):
        print(self.name)
        print(self.__name)
obj = A()
obj.func()

• 类的外部不能访问

class A:
    name = '李业'
    __name = '钢哥'  # 私有类的属性

    def func(self):
        pass

obj = A()
print(obj.name)
print(A.__name)
print(obj.__name)

• 类的子类不能访问

class A:
    name = '李业'
    __name = '钢哥'

class B(A):
    def func(self):
        print(self.__name)

obj = B()
# print(obj.__name)
obj.func()

私有类的方法

只能在类的内部使用，不能在类外部以及子类使用

class A:
    def func(self):
        self.__func()
        print("in A func")

    def __func(self):
        print("in A __func")
obj = A()
# obj.func()
obj.__func()

私有对象的属性

只能在类的内部使用，不能在类外部以及子类使用

应用:用户密码

class A:
    def __init__(self, name, pwd):
        self.name = name
        self.__pwd = pwd
    def md5(self):
        self.__pwd = self.pwd + "123"
obj = A("李业", "liyedsb")

类方法

类名调用的方法,将类名地址自动传给cls参数

类方法：一般就是通过类名去调用的方法，并且自动将类名地址传给cls，但是如果通过对象调用也可以，但是传的地址还是类名地址

类方法的作用：

• 得到类名可以实例化对象
• 可以操作类的属性

class A:
    def func(self):
        print("实例方法")

    @classmethod
    def cls_func(cls):
        # print(f"cls---->{cls}")
        obj = cls()
        print(obj)
        print("类方法")
# print(A)
# A.cls_func()
obj1 = A()
obj1.cls_func()

简单应用

创建学生类，只要实例化一个对象，写一个类方法，统计一下具体实例化多少个学生？

class Student:
    count = 0

    def __init__(self, name, id):
        self.name = name
        self.id = id
        Student.count += 1

    @classmethod
    def count_a(cls):
        print(f"{cls.count}个")

obj1 = Student("zdr", 1)
obj2 = Student("zdr1", 2)
obj3 = Student("zdr2", 3)
obj4 = Student("zdr3", 4)
obj5 = Student("zdr4", 5)
Students.count_a()

静态方法

静态方法是不依赖对象与类的，其实静态方法就是函数

作用：保证代码的规范性，合理的划分，后续维护性高

class A:
    def func(self):
        print("实例化方法")

    @staticmethod
    def static_func():
        print("静态方法")

事例

import time
class TimeTest:
    area = "中国"

    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    def change_time(self):
        print(f"你想调整的时间：{self.hour}时{self.minute}分{self.second}秒")

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())

t = TimeTest(2, 10, 10)
t.change_time()
print(TimeTest.showTime())

属性

将动态方法 伪装 成了一个属性,虽然在代码级别上没有什么提升,但是让你看起来更合理.

property 将执行一个函数需要函数名()变换成直接函数名.

应用场景

• 面试会考一些基本的调用，流程
• 工作中如果遇到了一些类似于属性的方法名，可以让其伪装成属性

# class Bmi:
#
#     def __init__(self,name,height,weight):
#
#         self.name = name
#         self.height = height
#         self.weight = weight
#
#     def bmi(self):
#         return self.weight/self.height**2
#
# obj = Bmi('赵嘎', 1.83, 65)
# print(obj.bmi())
# 结果虽然实现了,但是逻辑上感觉不合理.bmi应该是类似于name,age,height,等名词,
# 但是你把它当做方法使用了.

# class Bmi:
#
#     def __init__(self,name,height,weight):
#
#         self.name = name
#         self.height = height
#         self.weight = weight
#
#     @property
#     def bmi(self):
#         return self.weight/self.height**2
#
# obj = Bmi('赵嘎', 1.83, 65)
# print(obj.bmi)
# property 将执行一个函数需要函数名()变换成直接函数名.
# 将动态方法 伪装 成了一个属性,虽然在代码级别上没有什么提升,但是让你看起来更合理.
# obj.bmi
# obj.bmi
# obj.bmi = 666
#
# del obj.bmi

# property 他是一个组合.

# class Foo:
#     @property
#     def bmi(self):
#         print('get的时候运行我啊')
#
#     @bmi.setter
#     def bmi(self,value):
#         print(value)
#         print('set的时候运行我啊')
#         # return 111  # 无法得到返回值
#
#     @bmi.deleter
#     def bmi(self):
#         print('delete的时候运行我啊')
#         # return 111  # 无法得到返回值
#
# obj = Foo()
# # obj.bmi
# obj.bmi = 666 # 操作命令 这个命令并不是改变bmi的值,而是执行被bmi.setter装饰器装饰的函数
# # obj.bmi(666)
# del obj.bmi
# 应用场景:
    # 1, 面试会考一些基本的调用,流程.
    # 2, 工作中如果遇到了一些类似于属性的方法名,可以让其伪装成属性.

设置属性的两种方式：

• 利用装饰器设置属性

class Foo:
    @property
    def bmi(self):
        print("get的时候运行我啊")

    @bmi.setter
    def bmi(self, value):
        print(value)
        print("set的时候运行我啊")
        # return 111 无法得到返回值

    @bmi.deleter
    def bmi(self):
        print("delete的时候运行我啊")
        # return 111 无法得到返回值

• 利用实例化对象的方式设置属性

class Foo:
    def get_AAA(self):
        print("get的时候运行我啊")

    def set_AAA(self, value):
        print("set的时候运行我啊")

    def delete_AAA(self):
        print("delete的时候运行我啊")
    AAA = property(get_AAA,set_AAA,delete_AAA) # 内置property三个参数与get，set，delete一一对应
f1 = Foo()
f1.AAA
f1.AAA = "aaa"
del f1.AAA

isinstance、issubclass的区别

isinstance函数

判断的是对象和类的关系

isinstance(a,b)：判断的是 a是否是b类 或者 b类派生类 实例化的对象.

class A:
    pass

class B(A):
    pass

obj = B()
print(isinstance(obj, B))  # True
print(isinstance(obj, A))  # True

issubclass函数

类与类之间的关系

issubclass(a,b)：判断的是 a类是否是b类的子孙类

class A:
    pass

class B(A):
    pass

class C(B):
    pass
print(issubclass(B,A))  # True
print(issubclass(B,A))  # True

总结

私有成员：只能在类的内部调用

类方法：@classmethod 类名--->cls 实例化对象，操作类的属性

静态方法：@staticmethod 保持代码的一致性，提高代码的维护性

属性：将方法 伪装 成属性，看起来更合理

issubclass(a,b) ：a 是否是 b的子孙类

isinstance(a,b)：a 是否是 b类或者b类的派生类的实例化对象