面向对象:类的成员

类的成员(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