day⑦:类的3大成员

Posted 寻找伯乐

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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





以上是关于day⑦:类的3大成员的主要内容,如果未能解决你的问题,请参考以下文章

面向对象day08:类的特殊成员-类的起源与metaclass

day6面向对象--类的特殊成员方法

CGBTN2108-DAY10总结复习

day08面向对象-内部类异常

days13--内部类与匿名内部类

Java面向对象 类的成员之代码块的详解