Python基础—面向对象（进阶篇）

Posted 摘星者的博客

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python基础—面向对象（进阶篇）相关的知识，希望对你有一定的参考价值。

通过上一篇博客我们已经对面向对象有所了解，下面我们先回顾一下上篇文章介绍的内容：

上篇博客地址：http://www.cnblogs.com/phennry/p/5606718.html

  • 面向对象是一种编程方式，此编程方式的实现是基于对类和对象的使用；

  • 类是一个模版，模板中包装了多个方法供使用（这里方法就是函数）；

  • 对象，根据模板创建的实例，实例用于调用被包装在类中的函数；

  • 面向对象的三大特性：封装、继承、多态。

今天博客的内容主要介绍：Python类的成员、成员修饰符、类的特殊成员、异常处理和单例模式。下面开始今天的内容：

 一、类的成员

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


 注：所有的成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段；

       其他成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

下面开始介绍类的成员：

    （一）、字段

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

  • 普通字段属于 对象

  • 静态字段属于 类

 

1
2
3
4
5
6
7
8
9
10
11
12
13
class Func():
    country = "中国"              #静态字段，保存在类里面
 
    def  __init__(self,name):
        self.name = name         #普通字段，保存在对象里
 
 
#普通字段访问方法
hn = Func(\'河南\')
print(hn.name)
 
#静态字段访问方法
print(Func.country)

由上述代码可以看出【普通字段需要通过对象来访问】【静态字段通过类访问】，在使用上可以看出普通字段的归属是不同的。其内部的存储方式类似下图：

 在Python中，可以通过类对象指针，找到类的静态字段。

 字段的定义规则：

  • 普通字段只能用对象访问；

  • 静态字段用类访问(万不得已的时候可以使用对象访问)，静态字段在代码加载时候，就已经创建。

     

     （二）、方法

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

  • 普通方法：有对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self;

  • 静态方法：有类调用；无默认参数；

  • 类方法：有类调用；至少一个cls参数；执行类方法时，自动将该方法的类复制给self，即：cls为类名。

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
class Func():
    country = "中国"
 
    def  __init__(self,name):
        self.name = name
        #self.name
 
       
      def show(self):           # 普通方法：由对象去调用执行(方法属于类),至少一个self
          print(self.name)
 
                                # 静态方法：不依赖任何对象，由类调用执行,任意参数
      @staticmethod             #创建静态方法的时候要把self去掉，再方法的上面加上@staticmethod
      def f1(arg1,arg2):
          print(arg1,arg2)
 
     
      @classmethod             #创建类方法，至少一个cls,cls是python自动传入的，
      def  f2(cls):            #cls为类名，是一个类，不是一个字符串
          print(cls)
 
 
#调用普通方法：
obj = Func()
obj.show()
 
#调用静态方法：
Func.f1()
 
#调用类方法：
Func.f2()

 相同点：对于所有的方法而言，均属于类(非对象)中，所以在内存中只保存一份；

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

 

 

     （三）、属性

python中属性其实就是普通方法的变种，这里我们介绍三个知识点：属性的基本使用，属性的两种定义方式。

    1、属性的基本使用

 

1
2
3
4
5
6
7
8
9
10
11
12
class Foo:
    def func(self):
        pass
  
    @property           #定义属性
    def prop(self):
        pass
  
foo_obj = Foo()         #创建对象
  
foo_obj.func()    
foo_obj.prop             #调用属性

定义方法：

  • 定义时，在普通方法的基础上添加@property装饰器；

  • 定义时，属性仅有一个self参数；

  • 调用时，无需括号，方法调用时为foo_obj.func() ，调用属性时为foo_obj.prop

注意：属性存在意义是：访问属性可以制造出字段完全相同的假象，属性有方法变种而来，如果python中没有属性，方法完全可以代替其功能。

下面举个例子：

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

  • 根据用户请求的当前页面和总数据条数计算出m和n;

  • 根据m和n去数据库中请求数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Pager:
    
    def __init__(self,current_page):
        self.current_page     #用户当前请求的页码(第一页、第二页...)
        self.per_items = 10   #每页默认显示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
 
p = Pager(1)
p.start   #起始值m
p.end     #结束值n

从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果放回。

 

    2、属性的两种定义方式

属性定义有两种方式：

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

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

装饰器的方式：

      我们知道python2.*中的类有经典类和新式类，在python3.*中只有新式类，因为现在python3.*在企业中还没有广泛应用，这里先安装python2.*介绍：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
#################经典类####################
class Goods:
     
    @property            #定义类属性
    def price(self):
        return "jack"
 
obj =Goods()
result = obj.price       #自动执行@property装饰的price方法，并获取方法的返回值
print(result)
 
#结果:
jack

python2.*中的经典类，具有一种@property装饰器，如上例；下面来看一下新式类：

 

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
#################新式类#####################
 
class Goods(object):
     
    @property
    def price(self):
        print(\'get price\')
 
    @price.setter
    def price(self,value):
        print(\'set price\')
 
    @price.deleter
    def price(self):
        print(\'del price\')
 
 
 
#调用方法：
 
obj = Goods()
 
obj.price       #自动执行@property修饰的price方法，并获取方法的返回值
 
obj.price(123)  #自动执行@property.setter修饰的price方法,并将123赋值给方法的参数
 
del obj.price   #自动执行@property.deleter修饰的price方法，将方法删除

注: 经典类中的属性只有一种访问方式，其对应被@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
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):
        del self.original_price
  
obj = Goods()
obj.price        #获取商品价格
obj.price = 200  #修改商品价格
del obj.price    #删除商品价格

 

静态字段的方式：

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
24
25
26
27
28
29
30
class Goods(object):
 
    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8
 
    def get_price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price
 
    def set_price(self, value):
        self.original_price = value
 
    def del_price(self):
        del self.original_price
 
    PRICE = property(get_price, set_price, del_price, \'价格属性描述...\')
 
obj = Goods()
ret =obj.PRICE
print(ret)
 
obj.PRICE = 200
ret1 =obj.PRICE
print(ret1)
 
del obj.PRICE

所以，定义属性共用两种方式，分别是【装饰器方式】和【静态字段】，而【装饰器方式】针对经典类和新式类又有所不同。

 

 二、类成员的修饰符

类的所有成员在上一步骤已经做了详细介绍，对于每一个类的成员而言都是有两种形式的：

  • 公有成员：在任何地方都能访问；

  • 私有成员：只有在类的内部才能访问。

 私有成员和公有成员的定义不同：私有成员时，前两个字符是下划线（类似：__init__、__call__、__dict__等）

 

1
2
3
4
5
class Foo:
 
    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
Python之路第八篇：Python基础（24）——面向对象进阶

[资料分享]Python视频教程（基础篇进阶篇项目篇）

Python学习笔记——基础篇第七周———FTP作业（面向对象编程进阶 & Socket编程基础）

Python面向对象编程进阶

Python面向对象编程进阶

Python面向对象编程进阶

(c)2006-2024 SYSTEM All Rights Reserved IT常识