• 面向对象:类的成员


    类的成员(3种): 变量, 方法, 属性
    1. 变量(2种):实例变量, 类变量
     1 class Foo:
     2     country = "中国"         #类变量(静态字段)
     3     def __init__(self,name): #实例变量(字段)
     4         self.name = name
     5     def func(self):
     6         pass
     7 
     8 obj1 = Foo("季红")
     9 obj2 = Foo("王小二")
    10 print(obj1.name)
    11 print(Foo.country)
    准则: 实例变量(字段)访问的时候用对象访问, 例如:obj.name
    类变量(静态字段)访问的时候用类访问, 例如:Foo.country


     1 # 知识点一:易错点
     2 """
     3 obj1 = Foo('季红')
     4 obj2 = Foo('王晓东')
     5 
     6 # 练习1
     7 # obj1.name = 'alex'
     8 # print(obj1.name) # alex
     9 # print(obj2.name) # 王晓东
    10 
    11 # 练习2
    12 # obj1.country = '美国'
    13 # print(obj1.country) # 美国
    14 # print(obj2.country) # 中国
    15 
    16 # 练习3
    17 # Foo.country = '美国'
    18 # print(obj1.country) # 美国
    19 # print(obj2.country) # 美国
    什么时候用类变量?
    当所有对象中有共同实例变量(字段)的时候,并且这些变量要改都改,要删都得删的时候,可将实例变量(字段)提取到类变量(静态字段)

    实例变量: 公有变量和私有变量
    类变量: 公有变量和私有变量
     1 # --------------公有实例变量 -----------
     2 class Foo:
     3     def __init__(self, name):
     4         self.name = name
     5         self.age = 23
     6 
     7     def func(self):
     8         print(self.name)
     9 
    10 obj = Foo("alex")
    11 print(obj.name) #alex
    12 print(obj.age)  #23
    13 obj.func() #alex
    14 
    15 # ------------私有实例变量 -----------------
    16 class Foo:
    17     def __init__(self, name):
    18         self.__name = name
    19         self.age = 23
    20     def func(self):
    21         print(self.__name)
    22 
    23 obj = Foo("alex")
    24 # print(obj.name)  # 访问不到了, 可以通过func 访问到
    25 print(obj.age)  # 23
    26 obj.func()  # alex
    27 
    28 # ----------------公有类变量--------------
    29 class Foo:
    30     country = "中国"
    31     def __init__(self):
    32         pass
    33     def func(self):
    34         #内部调用
    35         # print(self.country)
    36         print(Foo.country) # 推荐
    37         # pass
    38 #外部调用
    39 print("外部调用",Foo.country)
    40 obj = Foo()
    41 obj.func()
    42 
    43 # ----------------私有类变量--------------
    44 class Foo:
    45     __country = "中国"
    46     def __init__(self):
    47         pass
    48     def func(self):
    49         #内部调用
    50         # print(self.__country)
    51         print("内部调用", Foo.__country) # 推荐
    52         # pass
    53 
    54 #外部无法调用 **********************
    55 # print("外部调用",Foo.country)
    56 obj = Foo()
    57 obj.func()

    2. 方法: 实例方法, 静态方法, 类方法

     1 # 实例方法
     2 class Foo(object):
     3     def __init__(self,name):
     4         self.name = name
     5     def func(self): # 直接打印,没有用到已经封装的值,没必要写实例方法
     6         print("233333")
     7 obj = Foo("alex")
     8 obj.func()
     9 
    10 
    11 
    12 class Foo(object):
    13     def __init__(self,name):
    14         self.name = name
    15 
    16     #实例方法
    17     def func(self):
    18         print(self.name)
    19 obj = Foo("alex")
    20 obj.func()
    21 
    22 
    23 
    24 # 静态方法
    25 class Foo(object):
    26     def __init__(self, name):
    27         self.name = name
    28 
    29     #实例方法
    30     def func(self):
    31         print(self.name)
    32 
    33     # 静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法
    34     @staticmethod
    35     def display(a1, a2):
    36         return a1 + a2
    37 
    38 obj = Foo("123")
    39 obj.func()
    40 print(obj.display(2,4))
    41 ret = Foo.display(1,3)
    42 print(ret)
    43 # 总结: 编写时:
    44 #        方法上方写@staticmethod
    45 #        方法参数可有可无
    46 #       调用时:
    47 #         类.方法名() #推荐
    48 #         对象.方法名()
    49 #       什么时候用静态方法?
    50 #           无需调用对象中已经封装的值
    51 
    52 
    53 # 类方法
    54 class Foo(object):
    55     def __init__(self,name):
    56         self.name = name
    57 
    58     #实例方法,self是对象
    59     def func(self):
    60         print(self.name)
    61 
    62     #静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法
    63     @staticmethod
    64     def display(a1,a2):
    65         return a1 + a2
    66 
    67     #类方法, cls是类
    68     @classmethod
    69     def show(cls,x1,x2):
    70         return x1 + x2
    71 
    72 #执行类方法
    73 ret = Foo.show(3,4)
    74 print(ret)
    75 
    76 #总结:
    77 #   定义时:
    78 #         方法上方写: @classmethod
    79 #         方法的参数: 至少有一个cls参数
    80 #   执行时:
    81 #       类名.方法名() #默认会从当前类传到参数中
    82 #   什么时候用?
    83 #       如果在方法中会使用到当前类,那么就可以使用类方法

    实例方法: 公有变量 和 私有变量

    静态方法: 公有变量 和 私有变量

    类方法: 公有变量 和 私有变量

     1 # ------------私有的实例方法--------------
     2 class Foo(object):
     3 
     4     def __init__(self):
     5         pass
     6     def __display(self,arg):
     7         print("私有方法",arg)
     8 
     9     def func(self):
    10         self.__display(123)
    11 
    12 obj = Foo()
    13 # obj.__display(123) #无法访问
    14 obj.func()
    15 
    16 # ------------私有的静态方法--------------
    17 
    18 class Foo(object):
    19 
    20     def __init__(self):
    21         pass
    22 
    23     @staticmethod
    24     def __display(arg):
    25         print("私有静态方法",arg)
    26 
    27     def func(self):
    28         self.__display(123)
    29 
    30     @staticmethod
    31     def get_display():
    32         Foo.__display(88888) # 类.方法名() 调用静态方法
    33 
    34 # Foo.__display(123) #报错
    35 obj = Foo()
    36 obj.func()
    37 Foo.get_display()

    3. 属性

    # 属性(通过方法改造出来)
    
    class Foo(object):
        def __init__(self):
            pass
    
        @property
        def start(self):
            return 1
    
        @property
        def end(self):
            return 10
    obj = Foo()
    print(obj.start)
    print(obj.end)
    
    #总结:
    #   1.编写时:
    #         方法上写 @property
    #         方法参数: 只有一个self
    # 2.调用时: 无需加括号   对象.方法
    # 3.应用场景: 对于简单的方法,当无需传参且有返回值时,可以使用 @property
  • 相关阅读:
    vim中ctags应用
    LCD屏参数及应用举例
    modbus概述
    Modbus常用
    git常用操作
    linux内核学习
    截图工具gsnap
    信号signal编号及意义及一般处理
    oracle 表空间 数据文件 表的关系
    IBM MQ 2035 或 2013认证错误的解决方法
  • 原文地址:https://www.cnblogs.com/kenD/p/9550289.html
Copyright © 2020-2023  润新知