Python面向对象

Python是一门面向对象的语言，在Python中一切都是对象，函数是对象，类型也是对象

主要内容

1. 简单说明面向对象和面向过程的区别
2. 类的成员，成员修饰符，类的特殊成员

简单说明面向对象和面向过程的区别

• 面向过程：就是一条流水线，比如你要为客户写一个关于《渴络新对避免心脑血管疾病的有效性》的eCRF问卷系统，接到之后要直接上手写，这时候我们不考虑复用性，思考每一步怎么实现，define每个功能。OK，顺利交工。But，下一个项目来了，但他不是渴络新，而是肖本地平。就不得不重写所有功能（当然可以CV大法），面向过程更利于学习，但在工作里用着实不方便。

• 面向对象：面向对象编程有三大特性：封装，继承，多态（Python不支持且用不到）。有了封装和继承，就可以把一套流水线功能记录在一个模板里了。这样，这样就下次接到新项目的时候，只需要写一下特有的功能，而通用功能直接继承模板就好。

这点不做过多的赘述，主要了解一下面向对象的优势。

类的成员，成员修饰符，类的特殊成员

类的成员，成员修饰符，类的特殊成员
1.类的成员

• 类的成员
  • 字段
    • 普通字段
    • 静态字段
  • 方法
    • 普通方法
    • 类方法
    • 静态方法
  • 属性

1.字段
普通字段属于对象，静态字段属于类：

class Province:
 
    # 静态字段
    country ＝ '中国'
 
    def __init__(self, name):
 
        # 普通字段
        self.name = name
 
# 直接访问普通字段
obj = Province('河北省')
print obj.name
 
# 直接访问静态字段
Province.country

值得注意的是，类占一份内存，而每个实例（对象）单独占一份内存。同时，静态字段只会于类中保存一份，而普通字段每个对象都要保存一份。

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

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

class Foo:
 
    def __init__(self, name):
        self.name = name
 
    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """
 
        # print self.name
        print '普通方法'
 
    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
 
        print '类方法'
 
    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""
 
        print '静态方法'
 
# 调用普通方法
f = Foo()
f.ord_func()
 
# 调用类方法
Foo.class_func()
 
# 调用静态方法
Foo.static_func()

3.属性
属性就是普通方法的变种。

对于属性，有以下三个知识点：

• 属性的基本使用
• 属性的两种定义方式

由属性的定义和调用需要注意的是：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
  方法：foo_obj.func()
  属性：foo_obj.prop

# ############### 定义 ###############
class Foo:
 
    def func(self):
        pass
 
    # 定义属性
    @property
    def prop(self):
        pass
# ############### 调用 ###############
foo_obj = Foo()
 
foo_obj.func()
foo_obj.prop   #调用属性

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

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

根据用户请求的当前页和总数据条数计算出 m 和 n
根据m 和 n 去数据库中请求数据

# ############### 定义 ###############
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(1)
p.start 就是起始值，即：m
p.end   就是结束值，即：n

属性的两种定义方式

属性的定义有两种方式：

• 装饰器 即：在方法上应用装饰器
• 静态字段 即：在类中定义值为property对象的静态字段
  装饰器方式：在类的普通方法上应用@property装饰器

这里顺便提一句Python中的新式类和经典类
新式类继承object，属性更丰富
区别为新式类的继承关系是广度优先，而经典类是深度优先。

class A: #经典类
	pass
	
class B(Object): # 新式类
	pass

直接上新式类的@property装饰器

# ############### 定义 ###############
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对象的静态字段

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()
obj.PRICE         # 获取商品价格
obj.PRICE = 200   # 修改商品原价
del obj.PRICE     # 删除商品原价