python入门（五）：面向对象

面向对象术语

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 实例变量：定义在方法中的变量，只作用于当前实例的类。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

类对象

1.类对象支持两种操作：属性引用和实例化。

2.属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

3.类对象创建后，类命名空间中所有的命名都是有效属性名。

4.很多类都倾向于将对象创建为有初始状态的，因此类可能会定义一个名为 __init__() 的特殊方法（构造方法）。

5.对于每一个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，以__开始，只有在类的内部才能方法

6.经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法。从写法上区分的话，如果当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

• 当类是经典类时，多继承情况下，会按照深度优先方式查找
• 当类是新式类时，多继承情况下，会按照广度优先方式查找

class Test:

#!/usr/bin/python3

#经典类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s say: i am %d years old." %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s say: i am %d years old,i am %d grade."%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()

　　

一、字段

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

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

class Province:
    # 静态字段
    country ＝ '中国'

    def __init__(self, name):
        # 普通字段
        self.name = name

# 直接访问普通字段
obj = Province('河北省')
print obj.name

# 直接访问静态字段
Province.country

　　

二、方法

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

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

#!/usr/bin/python
class Foo:

    def __init__(self, name):
        self.name = name

    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """
        print(self.name)
        print('1')

    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        print('2')

    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print('3')

# 调用普通方法
f = Foo("xx")
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()

　　

三、属性　　

如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。

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

• 属性的基本使用：调用时，无需括号。
• 属性的两种定义方式：静态字段和装饰器，装饰器定义时，在普通方法的基础上添加 @property 装饰器，属性仅有一个self参数。

1.装饰器定义时，经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

#!/usr/bin/python
# ############### 经典类装饰器属性 ###############
class Goods:

    @property
    def country(self):
        return "china"
# ############### 调用 ###############
obj = Goods()
result = obj.country  # 自动执行 @property 修饰的 country 方法，并获取方法
print(result)

# ############### 新式类装饰器属性 ###############
class Goods(object):

    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self, value):
        print('@price.setter')

    @price.deleter
    def price(self):
        print('@price.deleter')

# ############### 调用 ###############
obj = Goods()
obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price

　2.静态字段方式，创建值为property对象的静态字段

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

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

• 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
• 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
• 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
• 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

class Price(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,value):
        del self.original_price

    PRICE = property(get_price, set_price, del_price, 'xxxx')

obj = Price()
print("before:",obj.PRICE)  # 获取原始商品价格，调用get_price
obj.PRICE = 200   # 修改商品原价，调用set_price
print("after:",obj.PRICE)  # 获取修改后商品价格，调用get_price
#del obj.PRICE   # 删除商品原价，调用del_price
obj.PRICE.__doc__    # 自动获取第四个参数中设置的值

四、类的特殊成员

      　1、__doc__类或对象的描述信息

2、__module__ 和__class__ 当前对象属于哪个模块或那个类

3、__init__构造方法，通过类创建对象时，自动触发执行。方法意义重大的原因有两个，第一是在对象生命周期中初始化是最重要的一步；每个对象必须正确初始化后才能正常工作。第二是__init__()参数值可以有多种形式。

#!/usr/bin/python
class Rectangle:
	def __init__(self):
		#初始化
		self.length=7
		self.width=7
	def area(self):
		return self.length * self.width

if __name__=="__main__":
	r=Rectangle()
	#如果__init__未做初始化，则需要显示赋值
	r.length, r.width = 13, 8
	print(r.area())

　　　4、__del__析构方法，当对象在内存中被释放时，自动触发执行。

5、__call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

6、__dict__类或对象中的所有成员

class Province:

    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print(self.name)
#查看对象有哪些属性和方法
print(dir(Province))
# 获取类的成员，即：静态字段、方法、
print(Province.__dict__)
obj1 = Province('hebei',100)
print(obj1.__dict__)

　　7.如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

　　8、__getitem__、__setitem__、__delitem__用于索引操作，如字典。以上分别表示获取、设置、删除数据

　　9、__getslice__、__setslice__、__delslice__该三个方法用于分片操作

　　10. __iter__ 用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__

参考：http://www.cnblogs.com/wupeiqi/p/4766801.html