day⑦:类的3大成员

start

py3


类的三大成员： 字段(变量)  、属性、方法


一.字段(实例变量和类变量)

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#!/usr/bin/env python
#coding=utf-8
 
class Province:
    '''
    字段(变量)包括：普通字段(实例变量)和静态字段(类变量)，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
 
    普通字段(实例变量)属于对象
    静态字段(类变量)属于类
    '''
 
    #静态字段(类变量)
    country="中国"
 
    def __init__(self,name):
 
        #普通字段(实例变量)
        self.name=name
 
 
 
#直接访问普通字段(实例变量)
obj=Province("广州")
print(obj.name)
 
obj.name="你妹"
obj.name2="你妹2"
obj.yaobin="自己定义实例变量"
 
print(obj.name)
print(obj.name2)
print(obj.yaobin)
 
 
 
#直接访问静态字段(类变量)
print(Province.country)
 
 
 
##结果：
广州
你妹
你妹2
自己定义实例变量
中国



二.属性

①装饰器方式定义属性之新式类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#!/usr/bin/env python
#coding=utf-8
  
'''
装饰器方式：在类的普通方法上应用@property装饰器
'''
  
#新式类
class animal(object):
    '''
    新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
    '''
  
    def __init__(self, name):
        self.name = name
        self.num = None
  
  
  
    @property
    def price(self):
        return self.num
  
  
    @price.setter
    def price(self,num):
        self.num=num
        print("设置num",self.num)
  
  
    @price.deleter
    def price(self):
        print("删除",self.num)
        del self.num
  
  
  
dog=animal("随便")  #实例化
  
################################################################################
  
print(dog.price)  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
                  #输出是None
  
dog.price="123456"  # 自动执行 @price.setter 修饰的 price 方法，并将  123456 赋值给方法的参数
print(dog.price)     #现在是123456了
  
  
del dog.price     # 自动执行 @price.deleter 修饰的 price 方法
#print(dog.price)  #再打印，是会报错的
  
  
##结果：
None
设置num 123456
123456
删除 123456




②装饰器方式定义属性之经典类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/env python
#coding=utf-8
 
'''
装饰器方式：在类的普通方法上应用@property装饰器
'''
 
#经典类
class Goods:
    '''
    经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
    '''
    @property
    def price(self):
        return "yaobin"
 
 
 
obj=Goods()
result=obj.price #自动执行 @property 修饰的 price 方法，并获取方法的返回值
 
print(result)
 
 
#结果：
yaobin



③静态字段(类变量)方式定义属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#!/usr/bin/env python
#coding=utf-8
 
 
'''
创建值为property对象的静态字段(类变量)
'''
 
class Foo(object):
    '''
    当使用静态字段(类变量)的方式创建属性时，经典类和新式类无区别
    '''
    def __init__(self,name):
        self.name = name
        self.num = None
 
    def get_bar(self):
        return self.num
 
 
    #必须两个参数
    def set_bar(self,num):
        self.num=num
        print("设置num",self.num)
 
    def del_bar(self):
        print("我要删了num",self.num)
        del self.num
 
    BAR=property(get_bar,set_bar,del_bar,'描述信息')
 
 
 
obj=Foo("haha")  #实例化
 
#############调用##################
 # 自动调用第一个参数中定义的方法：get_bar
print(obj.BAR)
 
 
# 自动调用第二个参数中定义的方法：set_bar方法，并将123456当作参数传入
obj.BAR=123456
print(obj.BAR)
 
# 自动调用第三个参数中定义的方法：del_bar方法
del obj.BAR
#print(obj.BAR)  #再打印,报错！
 
 
##结果：
None
设置num 123456
123456
我要删了num 123456



三.方法

1.普通方法、2.类方法、3.静态方法

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#!/usr/bin/env python
#coding=utf-8
  
class Foo:
    '''
    方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
  
    普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
    类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
    静态方法：由类调用；无默认参数；
    '''
    test="gril" #类变量
  
    def __init__(self,name):
        self.name=name
  
    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """
        print("普通方法%s"%(self.name))
  
  
    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        #print("类方法 %s",self.name)  #不能访问普通字段(实例变量)
        print("类方法",Foo.test) #可以访问静态字段(类变量)
  
    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print("静态方法")   #不能访问类变量(静态字段)，也不能访问实例变量(普通字段),和类就一个组织逻辑关系，没什么用
  
  
#实例化
obj=Foo("yaobin")
  
  
  
#调用普通方法
obj.ord_func()
  
  
#调用类方法
Foo.class_func()
  
  
#调用静态方法
Foo.static_func()
  
  
##结果：
普通方法yaobin
类方法 gril
静态方法







end





posted on 2016-03-13 16:15  等待唐僧的日子  阅读(288)  评论(0)    收藏  举报