python面向对象-类成员种类

1     类的成员种类

成员公有：里面外面都能用

成员私有：内部使用，外部不能使用，外部想使用可以通过内部人。

1.1   变量

1.1.1 实例变量（字段）

所谓实例变量，先明白什么是实例，实例就是对象，就是类的实例化。因此实例变量就是对象变量。如下列例子：

class Foo:
    def __init__(self,name):
        self.name=name      #实例变量/字段
    def func(self):
        pass
obj = Foo('li')   

 

对于对象的理解：类单独建立一个空间，空间里有方法等元素，而对象有单独的空间

 

1.1.1.1  公有/私有实例变量

#################公有变量########
class Foo:
    def __init__(self,name):
        self.name=name      #实例变量/字段
    def func(self):
        print(self.name)
obj = Foo('li')
print(obj.name)         #li外部调用
obj.func()              #li内部调用
##############私有变量##########
class Foo:
    def __init__(self,name):
        self._name=name      #实例变量/字段
    def func(self):
        print(self._name)
obj = Foo('li')
print(obj.name)  # 报错  外部调用
obj.func()  # li 内部调用


python中

“单下划线” 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；
”双下划线” 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。

python中的命名方法：
1. object # 公用方法 
2. __object__ # 内建方法，用户不要这样定义 
3. __object # 全私有，全保护 
4. _object # 半保护

 

1.1.2 类变量（静态字段）

首先要明白什么是类变量？类变量就是在类中定义的变量

1.1.2.1  公有/私有类变量如何使用

##############公有类变量###############
class Foo:
    country = '中国'          #类变量（静态字段）
    def __init__(self,name):
        self.name = name        #实例变量（字段）
    def func(self):
        pass
obj1 = Foo('li')
obj1.country = '天地'
print(obj1.country)     #天地     #类变量的对象调用
print(Foo.country)      #中国      #类变量的类调用
Foo.country = '美国'          #类变量的修改方式
print(Foo.country)      #美国
##############私有类变量###############
class Foo:
    __country = '中国'          #类变量（静态字段）
    def __init__(self,name):
        self.name = name        #实例变量（字段）
    def func(self): #内部调用
        print(self.__country)   #对象调用内部
        print(Foo.__country)    #类调用内部
obj1 = Foo('li')
obj1.func()
print(Foo.__country)    #外部无法调用

1.1.2.2  类变量的应用场景

当所有对象中有共同的字段时且要改都改要删都删时,可以将 实例变量(字段) 提取到 类变量(静态字段)

 

准则:

#   实例变量(字段)访问时,使用对象访问,即: obj1.name

#   类变量(静态字段)访问时,使用类方法,即: Foo.country  (实在不方便时,才使用对象)

1.1.2.3  思考题

如何验证子类不知道父类的私有变量的存在？那么如果确定不知道，又该如何获取父类的私有变量？（以儿子想得知父亲的受贿情况为例）

# 无法访问:
class Base(object):
    __secret = "受贿"

class Foo(Base):
    def func(self):
        print(self.__secret)
        print(Foo.__secret)

obj = Foo()
obj.func()      #报错



# 可以访问:儿子可以通过观察老子的行为，1000的工资开兰博基尼肯定有问题
class Base(object):
    __secret = "受贿"

    def zt(self):
        print(Base.__secret)

class Foo(Base):

    def func(self):
        print(self.__secret)
        print(Foo.__secret)


obj = Foo()     
obj.zt()        #受贿

 

1.2   方法

1.2.1 公有/私有（成员修饰符） 实例方法

 

class Foo(object):

    def __init__(self,name):         #实例方法（构造方法）

        self.name = name

    def func(self):                #实例方法

        print('123')

 

obj = Foo('史雷')

obj.func()

 

######### 私有的实例方法 #######

class Foo(object):

    def __init__(self):

        pass

    def __display(self,arg):

        print('私有方法',arg)

    def func(self):

        self.__display(123)

 

obj = Foo()

# obj.__display(123) # 无法访问

obj.func()
公有：外部内部都能使用

私有：代码内部能使用，子类不能使用

应用场景：

如构造方法，如果没有用上，那么就没有意义。一般实例方法使用对象中封装的值

1.2.2 公有/私有 静态方法

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

    # 实例方法
    def func(self):
        print(self.name)

    # 静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法
    @staticmethod
    def display(a1,a2):
        return a1+a2


obj = Foo('li')
obj.func()
ret = Foo.display(1,3)
print(ret)

 

######### 私有的静态方法 #########

class Foo(object):

    def __init__(self):

        pass

    @staticmethod

    def __display(arg):

        print('私有静态 方法',arg)

    def func(self):

        Foo.__display(123)

    @staticmethod

    def get_display():

        Foo.__display(888)

 

# Foo.__display(123) 报错

 

obj = Foo()

obj.func()

 

Foo.get_display()

 

静态方法的特点

1. 编写时:

#        - 方法上方写 @staticmethod

#        - 方法参数可有可无

#   2. 调用时:

#       - 类.方法名()  *

#       - 对象.方法名()

#   3. 什么时写静态方法?

#       - 无需调用对象中已封装的值.

 

1.2.3 公有/私有 类方法（与静态方法类似）

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

    # 实例方法，self是对象
    def func(self):
        print(self.name)

    # 静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法
    @staticmethod
    def display(a1,a2):
        return a1+a2

    # 类方法,cls是类
    @classmethod
    def show(cls,x1,x2):
        print(cls,x1,x2)
        
Foo.show(1,8)   #<class '__main__.Foo'> 1 8   # # 执行类方法

 

 

######### 私有的类方法 #########

 

class Foo:
    def __init__(self,name):
        self.name = name
    # 类方法,cls是类
    @classmethod
    def show(cls):
        Foo.__show()   #内部调用

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

Foo.show()   #<class '__main__.Foo'>

Foo.__show() #报错  外部调用

 

# 总结

#   1. 定义时:

#        - 方法上方写: @classmethod

#        - 方法的参数: 至少有一个cls参数

#   2. 执行时:

#        - 类名.方法名()  # 默认会将当前类传到参数中.

#   3. 什么时用?

#        - 如果在方法中会使用到当前类,那么就可以使用类方法.

 

1.2.4 静态方法/类方法和实例方法的区别?

（1）：定义上

              实例：

                     方法的参数: 至少有一个self参数

              静态：

                     - 方法上方写 @staticmethod

                     - 方法参数可有可无

              类：

                     - 方法上方写: @classmethod

                     - 方法的参数: 至少有一个cls参数

 

（2）: 执行上

              实例：

                     需调用对象中已封装的值.

              静态：

                     无需调用对象中已封装的值.

              类：

                     - 类名.方法名()  # 默认会将当前类传到参数中.

 

（3）：应用场景上

              实例：

                     - 对象.方法名()

              静态：

                     - 类.方法名()  *

                     - 对象.方法名()

              类：

                     - 如果在方法中会使用到当前类,那么就可以使用类方法.

1.3   公有/私有 属性（通过方法改造来的）

 

如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。

 

对于属性，有以下三个知识点：

 

• 属性的基本使用
• 属性的两种定义方式

属性的基本使用

# ############### 定义 ###############
class Foo:

    def func(self):
        pass

    # 定义属性
    @property
    def prop(self):
        pass
# ############### 调用 ###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop   #调用属性

 

 

 

# 总结:

#     1. 编写时

#            - 方法上方写 @property

#            - 方法参数:只有一个self

#     2. 调用时:无需加括号  对象.方法

#     3. 应用场景: 对于简单的方法,当无需传参且有返回值时,可以使用 @property