码迷，mamicode.com
首页 > 编程语言 > 详细

Python进阶-面向对象

时间：2016-06-08 15:49:08      阅读：270      评论：0      收藏：0      [点我收藏+]

标签：

 

 

 

 

类的成员

类的成员可以分为三类：字段、方法、属性

一：字段：

普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同

  • 普通字段属于对象
  • 静态字段属于类

字段的定义和使用

技术分享
class Province:
    # 静态字段
    country = ‘中国‘
    def __init__(self,name):
        # 普通字段
        self.name = name
# 直接访问普通字段
obj = Province(‘北京‘)
print obj.name

# 直接访问静态字段
print Province.country
技术分享

点睛：

1：谁来调用：

     从上面可以看出普通字段需要通过对象来访问，静态字段通过类来调用。

2：存储的位置

技术分享

  1. 静态字段只存在把内存中一份，存在类的内存中
  2. 普通字段在每个对象中都要创建一份。

通过类创建对象的时候，如果每个对象都具有相同的字段，那么就使用静态字段

二：方法

普通方法、静态方法、类方法。三种方法在内存中都属于类，区别在于调用方式不同

  • 普通方法：由对象调用，至少一个self参数，执行普通方法时，自动将调用该方法的对象赋值给self
  • 类方法：由类调用，至少一个cls参数，执行类方法时，自动将调用该方法的类赋值给cls
  • 静态方法：由类调用，无默认参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Foo:
    # 初始化类
    def __init__(self):
        pass
    # 定义普通方法，至少有一个self参数
    def p(self):
        print ‘普通方法‘
    # 定义类方法，至少有一个cls参数
    @classmethod
    def q(cls):
        print ‘类方法‘
    # 定义静态方法
    @staticmethod
    def w():
        print ‘静态方法‘
# 调用普通方法
a = Foo()
ret = a.p()
# print ret
# 调用类方法
Foo.q()
# 调用静态方法
Foo.w()

点睛：

       相同点：对于所有的方法而言，均属于类中，所以在内存中也之保存一份

       不同点：方法调用者不同，调用方法时，自动传入的参数不同

三：属性

1：属性的基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Foo:
    def func(self):
        # print ‘func‘
        return ‘方法调用的返回值‘
 
    # 定义属性
    @property
    def prop(self):
        # print ‘prop‘
        return ‘属性调用的返回值‘
# 调用方法
obj = Foo()
ret = obj.func()
print ret
 
# 调用属性
ret1 = obj.prop
print ret1

技术分享

点睛：

  1. 定义时，在普通方法的基础上在上面添加@property装饰器
  2. 属性仅有一个self参数
  3. 调用时，无需括号

        方法：

              obj = Foo()

              ret = obj.func()

        属性：

              obj = Foo()

              ret = obj.prop

属性存在的意义：访问属性时，可以制造出和访问字段完全相同的假象

实例：

对于主机列表页面，每次请求不可能把数据库中的所有内容都显示到页面上，而是通过分页的功能局部显示，所以在向数据库中请求数据时就要显示的指定获取从第M条到第N条的所有数据，这个分页功能包括：

  1. 根据用户请求的当前和总数据条数计算出m和n
  2. 根据m和n去数据库请求数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Pager:
    def __init__(self,current_page):
        # 用户当前请求的页面
        self.current_page = current_page
        # 每页默认显示10条
        self.per_items = 10
    # 定义属性
    @property
    def start(self):
        val = (self.current_page - 1) * self.per_items
        return val
    @property
    def end(self):
        val = self.current_page * self.per_items
        return val
# 调用属性
p = Pager(2)
print  p.start
print  p.end
# 结果：
# 10
# 20

2：属性的两种定义方式

装饰器、静态字段

装饰器：在方法上应用装饰器

静态字段：在类中定义值为property对象的静态字段

装饰器方式：

经典类，具有一种@property装饰器

技术分享
# 定义类
class Foo:
    @property
    def fun(self):
        return ‘caoxiaojian‘
# 调用属性
obj = Foo()
ret = obj.fun
print ret
# 自动执行 @property修饰的fun方法，并获取方法的返回值
技术分享

 

新式类，具有三种@property装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Goods(object):
    @property
    def price(self):
        print ‘@property‘
    @price.setter
    def price(self,value):
        print ‘@price.setter‘,value
    @price.deleter
    def price(self):
        print ‘@price.deleter‘
 
# 调用
obj = Goods()
 
obj.price               # 自动执行@property修饰的price方法，并获取方法的返回值
obj.price = 123         # 自动执行@price.setter修饰的price方法，并将123赋值给方法的参数
del obj.price           # 自动执行@price.deleter修饰的price方法
执行结果：
@property
@price.setter 123
@price.deleter

注释：

经典类中的属性只用一种访问方式，其对应被@property修饰的方法

新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

因为新式类有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为同一个属性：获取、修改、删除

实例讲解:

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
class Goods(object):
    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8
 
    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price
 
    @price.setter
    def price(self,value):
        # 设置原始价格
        self.original_price = value
    @price.deleter
    def price(self,value):
        # 删除原始价格
        del self.original_price
# 调用
obj = Goods()
# 获取商品价格
obj.price
# 设置原始价格
obj.price = 3000
# 删除原始价格
del obj.price

静态字段方式:

创建值为property对象的静态字段

当使用静态字段的方式创建属性时，经典类和新式类无区别

1
2
3
4
5
6
7
8
9
class Foo:
    def get_bar(self):
        return ‘caoxiaojian‘
    BAR = property(get_bar)
 
obj = Foo()
# 自动调用get_bar方法，并获取方法的返回值。
ret = obj.BAR
print ret

property的构造方法中有个四个参数

  • 第一个参数是方法名，调用对象.属性时自动触发执行方法
  • 第二个参数是方法名，调用对象.属性 = xxx时自动触发执行方法
  • 第三个参数是方法名，调用del 对象.属性时自动触发执行方法
  • 第四个参数是字符串，调用对象.属性.__doc__此参数是该属性的描述信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Foo:
    def get_bar(self):
        return ‘caoxiaojian‘
    # 必须有两个参数
    def set_bar(self):
        return ‘set value‘ + value
    def del_bar(self):
        return ‘caoxiaojian===2‘
    BAR = property(get_bar, set_bar, del_bar,‘description......‘)
 
obj = Foo()
print obj.BAR           # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "caogaotian"  # 自动调用第二个参数中定义的方法：set_bar方法，将"caogaotian" 当作参数传入
print obj.BAR
del  obj.BAR            # 自动调用第三个参数中定义的方法：del_bar
print obj.del_bar()    
obj.BAR.__doc__         # 自动调用第三个参数中设置的值：‘description......‘
‘‘‘
结果输出：
caoxiaojian
caogaotian
caoxiaojian===2
‘‘‘

类成员的修饰符

两种形式：

  1. 私有成员：只有在类的内部才能访问的方法
  2. 公有成员：在任何地方都能访问

定义的不同：

私有成员命名时，前面两个字符是下划线。（特殊成员除外，例如：__init__等）

class C:
    def __init__(self):
        self.name = ‘公有字段‘
        self.__name = ‘私有字段‘

私有成员和公有成员的访问限制不同

静态字段

  • 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
  • 私有静态字段：仅类内部可以访问

公有静态字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class C:
    name = ‘公有静态字段‘
    def func(self):
        print C.name
class D(C):
    def func_1(self):
        print C.name
# 直接使用类访问
C.name
# 类内部访问
obj = C()
obj.func()
# 派生类内部访问
obj_1 = D()
obj_1.func_1()
‘‘‘
结果打印：
公有字段
公有字段
‘‘‘

私有静态字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class C:
    __name = ‘公有静态字段‘
    def func(self):
        print C.__name
class D(C):
    def func_1(self):
        print C.__name
# 类中访问
# C.__name    # 错误
# 类内部访问
obj = C()
obj.func()
# 派生类中访问
# obj_1 = D()    # 错误
# obj_1.func_1()

普通字段

  • 公有普通字段：对象、类、派生类都可以访问
  • 私有普通字段：只能在类内部访问

公有普通字段

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
class C:
    def __init__(self):
        self.foo = ‘公有字段‘
    def func(self):
        # 在类内部调用访问
        print self.foo
class D(C):
    def show(self):
        # 在派生类中调用访问
        print self.foo
obj = C()
# 通过对象访问
print type(obj.foo)
print  obj.foo
print ‘===========‘
# 类的内部访问
obj.func()
print ‘===========‘
obj_1 = D()
# 在派生类中访问
obj_1.show()
‘‘‘
结果打印:
<type ‘str‘>
公有字段
===========
公有字段
===========
公有字段
‘‘‘

私有普通字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class C:
    def __init__(self):
        self.__foo = ‘私有普通字段‘
    def func(self):
        # 类的内部调用访问
        print self.__foo
class D(C):
    def show(self):
        # 在派生类中调用访问
        print self.__foo
obj = C()
# obj.__foo      # 通过对象访问：报错
obj.func()       # 通过类内部访问
 
obj_1 = D()
#obj_1.show()    # 通过派生类调用访问： 报错

 

类的特殊成员

1：__doc__

表示类的描述信息

技术分享
class C:
    """
    这是描述信息，你看什么看？？
    """
    def func(self):
        pass
print C.__doc__
# 输出：这是描述信息，你看什么看？？
技术分享

2：__module__和__class__

__module__：表示当前操作的对象在哪个模块

__class__： 表示当前操作的对象的类是哪一个

在tmp模块下面有test.py和test1.py

test.py

class C:
    def __init__(self):
        self.name = ‘caoxiaojian‘

test1.py

技术分享
from test import C
# 根据导入的C类创建对象
obj = C()
# 获取对象中的模块名
print obj.__module__   # test
# 获取对象中的类名
print obj.__class__    # test.C
技术分享

3：__init__

构造方法，通过类创建对象时，自动触发执行

技术分享
class C:
    def __init__(self,name):
        self.name = name
        self.age = 18
obj = C(‘caoxiaojian‘) # 自动执行类中的__init__方法
print obj.name
技术分享

4：__call__

对象后面加括号，触发执行

点睛：

构造方法的执行是由创建对象触发的。即：对象名 = 类名()

__call__方法的执行由对象后面加括号触发的。即：对象()或者类名()()

技术分享
class C:
    def __init__(self):
        pass
    def __call__(self, *args, **kwargs):
        print ‘__call__‘

obj = C()      # 触发__init__
obj()          # 触发__call__
技术分享

5：__dict__

类或对象中的所有成员

技术分享

点睛：

类的普通字段属于对象，类中的静态字段和方法等属于类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Province:
    country = ‘china‘
    def __init__(self,name,count):
        self.name = name
        self.count = count
 
    def func(self, *args, **kwargs):
        print ‘func===func‘
 
# 获取类中的成员：静态字段和方法
print Province.__dict__
# {‘country‘: ‘china‘, ‘__module__‘: ‘__main__‘, ‘func‘: <function func at 0x021DA7F0>, ‘__init__‘: <function __init__ at 0x021DA870>, ‘__doc__‘: None}
 
# 调用类创建obj对象
obj = Province(‘shandong‘,100000)
print obj.__dict__
# {‘count‘: 100000, ‘name‘: ‘shandong‘}
 
# 调用类创建foo对象
foo = Province(‘beijing‘,20000)
print foo.__dict__
# {‘count‘: 20000, ‘name‘: ‘beijing‘}

类的分类：

经典类和新式类

技术分享
# 经典类
class func:
    def Foo(self):
        pass
# 新式类
class func_new(object):
    def Foo_new(self):
        pass
技术分享

点睛：

     区别：就是在类的后面加个object

类的继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 新式类
class D(object):
# 经典类
#class D:
    def bar(self):
        print ‘D.bar‘
class C(D):
    def bar(self):
        print ‘C.bar‘
class B(D):
    pass
class A(B,C):
    pass
a = A()
a.bar()
 
‘‘‘
经典类：深度优先  D.bar
新式类：广度优先  C.bar
‘‘‘

点睛：

经典类：深度优化

新式类：广度优化

技术分享

Python进阶-面向对象

标签：

原文地址：http://www.cnblogs.com/kevingrace/p/5569987.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！