标签：存储 基类 重要特性 nal 实例 lob 发送 影响 改变
----------------------
面向对象与类
#程序 = 指令+数据
代码可以选择以指令为核心或以数据为核心进行编写
#两种范型
以指令为核心：围绕“正在发生什么”进行编写
面向过程编程：程序具有一系列线型步骤：主题思想是代码作用于数据
以数据为核心：围绕"将影响谁"进行编写
面向对象编程：围绕数据及数据严格定义的接口来组织程序，用数据控制代码对代码的访问
所有编程语言最终目的都是提供一种抽象方法
&在机器模型（“解空间或方案空间”）与实际解决问题模型之间，程序员必须建立一种联系
面向过程：程序=算法 + 数据结构
面向对象：将问题空间中的元素以及他们在解空间中的表示物抽象为对象，允许通过问题来描述问题而不是方案
可以把对象（实例）想象成为一种新型变量，它保存着数据，但是可以对自身的数据执行操作
------------------------------------------------------------
面向对象核心概念：
类型由形态集合（数据）和转换这些状态的操作集合组成
#类抽象
类：定义了被多个同一类型对象共享的结构和行为（数据和代码）
类的数据和代码：即类的成员
数据：成员变量或实例变量
成员方法：简称为方法，是操作数据的代码，用于定义如何使用成员变量；因此一个类的行为和接口是通过方法来定义的
方法和变量：
私有：颞部使用
公有：外部可见
类定义了方法和数据结构
--------------------------------------------
面向对象程序设计方法：
所有东西都是对象
程序是一大堆对象的组合
通过消息传递，各对象知道自己该做什么
消息：即调用请求，它调用的是从属于目标对象的一个方法
每个对象都有自己的存储空间，并可容纳其它对象
通过封装现有对象，可以制作新型对象
每个对象都属于某一类型
类型，即类
对象是类的实例
类的一个重要特性为“能发什么样的消息给它”
同一个类的所有对象都能接受相同的消息
------------------------------------------------------
对象的接口
#定义一个类后，可以根据需要实例化出多个对象
#每个对象仅能接受特定的要求
能向对象发送的请求由其“接口”进行定义
对象的“类型”或“类”则规定了它的接口形式
类与类之间的关系：
1 依赖关系：一个类的方法操纵另一个类的对象
2 聚合：类A的对象包含类B的对象
3 继承：描述特殊与一般关系
一个对象获得另外一个对象属性的过程；用于实现按层分类的概念
一个深度继承的子类继承了类层次中它的每个祖先的所有属性
超类，基类，父类
子类，派生类
--------------------------------------
面向对象编程的原则：
封装，继承，多态
允许一个接口被多个通用的类动作使用的特性，具体使用哪个动作与应用场合相关
一个接口，多个方法
用于为一组相关的动作设计一个通用的接口，以降低程序复杂性
--------------- python类和实例-------------------------
类是一种数据结构，可用于创建实例
一般情况下，类封装了数据和可用于该数据的方法
Python类是一个可调用对象，即类对象
Python2.2之后，类是一种自定义类型，而实例则是生命某个自定义类型的变量
实例初始化
通过调用类来创建实例
instance = ClassName(args..)
类在实例化时可以使用__init__和__del__两个特殊方法
------------python中创建类-------------------------------
python使用class关键字创建类，语法格式如下
class classname(bases):
class documentation string
class_suit
超类是一个或多个用于继承的父类的集合
类体可以包含：声明语句，类成员定义，数据属性，方法
注意：
如果不存在继承关系：classname后面的"(bases)"可以不提供
类文档为可选
class语句的一般形式
class classname(bases):
data = value
def method(self,...):
self.member = value
例子：
python中，class语句类似def，是可执行代码；直到运行class语句后类才会存在。
>>>class FirstClass:
spam = 30 类属性
def display(self): 类方法，属于可调用的属性
print self.spam
>>>x = FirstClass() 创建类实例
>>>x.display() 调用方法
30
class语句内，任何赋值语句都会创建类属性
每个实例对象都会继承类额属性并获得自己的名称空间
------------python类方法及调用----------------
实例（对象）通常包含属性
可调用的属性：方法
object.method()
数据属性
在OOP中，实例就像是带有“数据”的记录，而类是处理这些记录的程序
通过实例调用方法相当于调用所属类的方法来处理当前实例
类似instance.method(args...)会被自动转换为
class.method()
如前面的例子，x.display()会被自动FirstClass.display()，即调用类的方法来处理实例
因此类中的每个方法必须具有self参数，它隐含当前实例之意
在方法内对self属性做赋值运算会产生每个实例自己属性
python规定，没有实例，方法不允许被调用，此即为绑定
----------类和实例的属性----------------
class语句中的赋值语句会创建类属性，如前面例子中的spam
在类方法中对传给方法的特殊参数self进行赋值会创建实例属性
例如：
>>>class myclass():
gender = "data"
def setname(self,x):
self.name = x
>>>aa = myclass()
>>>aa.gender
data
>>>aa.setname("wy")
>>>aa.name
wy
-----python构造器---------
创建实例时，python会自动调用类中的__init__方法，以隐性地为实例提供属性。
__init__方法被称为构造器
如果类中没有定义__init__方法，实例创建之初仅是一个简单的名称空间
>>>class myclass():
gender = "data"
def __init__(self,who):
self.name = who
----类的特殊属性-----------------------
可以使用类的__dict__字典属性或python内置的dir()函数来获取类的属性
class Myclass():
data = "hello myclass"
def __init__(self,who):
self.name=who
>>>dir(Myclass)
["__doc__","__init__","__module__","data"]
>>>Myclass.__dict__
{‘__doc__‘: None,
‘__init__‘: <function __main__.__init__>,
‘__module__‘: ‘__main__‘,
‘data‘: ‘hello myclass‘}
classname.__name__ 类的名字
classname.__doc__ 类的文档字符串
classname.__bases__ 类的所有父类构成的元组
classname.__dict__ 类的属性
classname.__module__ 类定义所在的模块
C.__class__ 实例C对应的类
-------实例属性--------------------------------------------
##实例仅拥有数据属性（严格意义上说，方法是类属性）
通常通过构造器"__init__"为实例提供属性
这些数据属性独立于其他实例或类
实例释放时，其属性也将被清除
##内建函数dir()或实例的特殊属性__dict__可用于查看实例属性
>>>dir()
>>>
实例的特殊属性
L.__class__ 实例化L的类
L.__dict__ L的属性
----------python类方法中可用的变量---------
实例变量：指定变量名称及实例自身进行引用
self.变量名
局部变量：方法内部创建的变量，可直接使用
类变量（也称静态变量）：通过指定变量名与类名进行引用
类名.变量名
全局变量：直接使用
>>> x = FirstClass()
>>> y = FirstClass()
>>> x.spam,y.spam
(30,30)
>>>x.spam = 40 为实例继承的属性重新赋值
>>>x.spam,y.spam
(40,30)
>>>FirstClass.spam = 56
>>>x.spam,y.spam
(40,30)
>>>FirstClass.spam = 56
>>>x.spam,y.spam
(40,56) 数字为不可变类型，因此x.spam已经已经指向其他对象，但是y.spam已经随类的重新赋值而改变
-----------------继承-------------------------------------------
继承描述了基类的属性如何“遗传”给派生类
子类可以继承它的基类的任何属性，包括属性和方法
一个未指定基类的类，其默认有一个名为object的基类
Python允许多重继承
创建子类
创建子类时，只需要在类名后跟一个或从其派生的父类
class SubClassName(ParentClass1[,ParentClass2,...])
optional class documentation string
class_suite
In [4]: class ParentClass(object):
...: "Parent Class"
...: gender = "Male"
...: def setName(self,who):
...: self.name = who
In [5]: class ChildClass(ParentClass):
...: "Child Class"
...: def displayInfo(self):
...: print self.gender,self.name
In [6]: x = ChildClass()
In [7]: x.setName("tom")
In [8]: x.displayInfo()
Male tom
------------python类的继承和属性搜索------
python中几乎所有属性的获取都可以使用”object.attribute“的格式
不过，此表达式会在python中启动搜索————搜索连续的树
class语句会产生一个类对象，对class的调用会创建实例，实例自动连接至创建了此实例的类
类连接至其超类的方式
将超类列在类头部的括号内，其从左至右的顺序会决定树种的次序
由下至上，由左至右
----------继承方法专用化---------------------------------
##继承会先在子类寻找变量名，然后才查找超类，因此，子类可以对超类的属性重新定义来取代继承而来的行为
子类可以完全取代从超类继承而来的属性
也可以通过已覆盖的方法回调超类来扩展超类的方法
例如：
>>>class ParClass(object):
def setinfo(self,sex="male"):
self.gender = sex
>>>class ChiClass(ParClass):
def setinfo(self,who): 注意：子类重新定义了超类
self.name = who
>>>xx = ChiClass()
>>>xx.name
10
>>>xx.gender 没有这个参数
AttributeError: ‘ChiClass‘ object has no attribute ‘gender‘
例如：
>>>class ParClass(object):
....: def setinfo(self,sex="wy"):
....: self.gender=sex
>>>class ChiClass(ParClass):
....: def setinfo(self,who): 这里也可以写作构造器__init__
....: self.name = who
....: ParClass.setinfo(self) 注意：这里实现了回调功能
>>>xx = ChiClass()
>>>xx.setinfo("tom")
>>>xx.name
Out[16]: ‘tom‘
>>>xx.gender
Out[19]: ‘wy‘
-----类，实例和其它对象的内建函数--------------------
issubclass()
布尔函数，判断一个类是否由另一个类派生，语法：issubclass(sub,sup)
例如：
>>>issubclass(ChildClass,ParentClass)
True
isinstance()
布尔函数，判断一个对象是否是给定类的实例，语法：isinstance(obi1,class_obj2)
hasattr() 常用来做反射
布尔函数，判断一个对象是否拥有指定的属性，语法：hasattr(obj,"attr")
同类的函数还有getattr()，setattr()和delattr()
例如：
>>> class cl():
data = "wy"
def __init__(self,name="www"):
self.user=name
>>> d1=c1()
>>>hasattr(d1,"data") 注意：要用引号
True
>>>hasattr(d1,"user")
True
super()
在子类中找出其父类以便于调用其属性
一般情况下仅能采用非绑定方式调用祖先类方法
而super()可用于传入实例或类型对象，语法：super(type[,obj])
--------------------运算符重载-------------------------------------
运算符重载是指在方法中拦截内置的操作————当类的实例出现在内置操作中，python
会自动调用自定义的方法，并且返回自定义方法的操作结果
运算符重载让类拦截常规的python运算
类可重载所有python表达式运算符
类也可重载打印，函数调用，属性点号运算等内置运算
重载使类实例的行为像内置类型
重载通过提供特殊名称的类方法实现
运算符重载并非必须，并且通常也不是默认
基于特殊的方法定制类：
除__init__和__del__之外,python类支持使用许多的特殊方法
特殊方法都以下双划线开头和结尾，有些特殊方法有默认行为，没有默认行为的是为留到需要的时候再实现
这些特殊方法是python中用来扩充类的强大工具，他们可以实现
模拟标准类型
重载操作符
特殊方法允许通过重载标准操作符+，*，甚至包括分段下表及映射操作[]来模拟标准类型
可调用对象：
函数
内置函数
自定义函数
def
lambda
类
类方法
函数属性：
__doc__
__name__
__dict__
__code__
__globals__
方法属性：
__doc__
__name__
__class__：方法所属类
__func__：实现该方法的函数对象
__self__：调用此方法的实例
内置函数：
__doc__
__name__
__self__
类：
__doc__
__name__
__bases__
__dict__
__module__：定义了当前类的模块名称
实例：
__class__
__dict__
对象都有特殊方法：
__init__，__new__，__del__
__dir__()
__add__()
__ge__()
a > b
a.__ge__(b)
标签：存储 基类 重要特性 nal 实例 lob 发送 影响 改变
原文地址：http://www.cnblogs.com/RomanticYori/p/6044759.html
