百万年薪python之路 -- 面向对象之所有属性及方法

1.私有成员公有成员

1.1 类的私有属性

# class A:
#
#     name = '周道镕'
#     __name = 'zdr'  # 私有类的属性
#
#     def func(self):
#         print(self.name)
#         print(self.__name)
# obj = A()
# obj.func()

结论:在类的内部可以访问

# class A:
#     name = '周道镕'
#     __name = 'zdr'  # 私有类的属性
#
#     def func(self):
#         pass
# obj = A()
# print(obj.name)
# print(A.__name)   #报错
# print(obj.__name) #报错

结论:类的外部不能访问

# class A:
#     name = '周道镕'
#     __name = 'zdr'  # 私有类的属性
#
# class B(A):
#     def func(self):
#         print(self.__name)
#
# obj = B()
# # print(obj.__name)
# obj.func()    # 报错

结论:类的派生类不能访问

1.2 类的私有方法

# class A:
#
#     def func(self):
#         self.__func()
#         print('in A func')
#
#     def __func(self):
#         print('in A __func')
#
# obj = A()
# obj.func()
# obj.__func()      # 报错

结论:类的私有方法不能在类的外部使用

1.3 对象的私有方法

class A:
    def __init__(self,username,pwd):
        self.username = username
        self.__pwd = pwd
    def md5(self):
        self.__pwd = self.__pwd + '123'
obj = A("7255322","123456789")
print(obj.__pwd)    # 报错

结论: 只能在类的内部使用,不能在类的外部使用以及派生类使用

私有成员来说: 当你遇到重要的数据,功能,(只允许本类使用的一些方法,数据)设置成私有成员.

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

class A:
    name = '周道镕'
    __name = 'zdr'  # 私有类的属性#
    def __func(self):
        print('in __func')
print(A.__dict__)
print(A._A__name)
A._A__func(123)
obj = A()
obj._A__func()

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

2.实例方法

实例方法就是类的实例能够使用的方法

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

3.类方法

加classmethod装饰器的方法就是类方法

class A:
    def func(self):
        print('实例方法')
    @classmethod
    def cls_func(cls):
        # print(f'cls---->{cls}')
        obj = cls()
        print(obj)
        print('类方法')
# A.cls_func()
# obj = A()
# obj.cls_func()

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

类方法有什么用???

1. 得到类名可以实例化对象.

2. 可以操作类的属性.

4.静态方法

使用装饰器@staticmethod。

# class A:
#
#     def func(self):
#         print('实例方法')
#
#
#     @classmethod
#     def cls_func(cls):
#         pass
#
#     @staticmethod
#     def static_func():
#         print('静态方法')

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

使用了静态方法（函数），然而方法体中并没使用（也不能使用）类或实例的属性（或方法）

保证代码的规范性,合理的划分.后续维护性高.

5.属性

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, 工作中如果遇到了一些类似于属性的方法名,可以让其伪装成属性.
# 设置属性的两种方式:
#     1, 利用装饰器设置属性.
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  # 无法得到返回值
    # 2. 利用实例化对象的方式设置属性.
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

6.issubclass isinstance区别

# isinstance 判断的是对象与类的关系
class A:
    pass
class B(A):
    pass
obj = B()
# isinstance(a,b) 判断的是 a是否是b类 或者 b类派生类 实例化的对象.
# print(isinstance(obj, B))  # True
# print(isinstance(obj, A))  # True
# issubclass 类与类之间的关系
class A:
    pass
class B(A):
    pass
class C(B):
    pass
# issubclass(a,b) 判断的是 a类是否是b类 或者 b类派生类 的派生类.
# issubclass(a,b) 判断的是 a类是否是b类 子孙类.
# print(issubclass(B,A))
# print(issubclass(C,A))

课外了解

按照Python的一切皆对象理论，类其实也是一个对象，那么类这个对象是从哪里实例化出来的呢？

print(type('abc'))
print(type(True))
print(type(100))
print(type([1, 2, 3]))
print(type({'name': '太白金星'}))
print(type((1,2,3)))
print(type(object))
class A:
    pass
print(isinstance(A, type))      # True
print(isinstance(object,type))  # True
print(issubclass(type,object))      # True

type元类是获取该对象从属于的类,而type类比较特殊，Python原则是：一切皆对象，其实类也可以理解为'对象',而type元类又称作构建类，python中大多数内置的类（包括object）以及自己定义的类，都是由type元类创造的。而type类与object类之间的关系比较独特：object是type类的实例，而type类是object类的子类，这种关系比较神奇无法使用python的代码表述，因为定义其中一个之前另一个必须存在。所以这个只作为了解。