python之面向对象简要剖析

__author__ = '李晓波'

Python面向对象简要剖析
如要下载附件阅读请将后缀改为.py，请使用"notepad++"打开此文档,"alt+0"将函数折叠后方便查阅

在python中一切皆为对象。面向对象编程的理论知识其实很好理解，说白了就是一堆名词，
把其中每个名词代表的含义，和他们之间的关系，面向对象就迎刃而解了。
python面向对象编程的基本名词：类、对象、方法、属性。
类和对象的关系：类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。
直观的说：坏人指的是一类人，是一部分人的一个集合。那么你是一个坏人，因为你具备坏人的一些特性，
其中坏人就是一个类，你就是类中的的一个对象。但实际编程中类不是那么太好划分，还需你多多使用。
类和对象定义的变量叫属性（attribute）：
其中类定义的叫类属性，对象定义的叫对象属性
类里的函数叫做方法（method）：是对象的动作
结论：对象=属性+方法
类的常见使用场景，把具有相同属性和方法的对象归为一个类（class）：
所以类经常用在：1、多个方法共用同样的变量，2、动态创建具有相同属性的对象。
类的三大特性：
多态：多态意味着可以对不同的对象使用同样的操作，但它们可能会以多种形态呈现出结果。
继承：面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制，
可先简单的理解为子类继承父类。
封装：类把所需要的属性和方法，封装在类中,其带来的好处有多个方法可以共用一组变量，
通过一个模板就可以创建多个对象。
类的成员：
字段（属性）：静态字段，动态字段
方法：动态方法（类里函数），静态方法，类方法
属性：一种为类和对象的变量，另一种为方法加装饰器前提类必须是新式类，
1、@property 2、@方法名.setter 3、@方法名.deleter,访问时以字段形式（所以也称它为属性，自己的理解）
类成员修饰符：
在属性或方法前面加__（两个横杠）,属性和方法就变为私有的，不可以被直接访问了。
引用某大神的图片，可更直观理解面向对象。其中个别名词不太一样，不要纠结，一个叫法而已



下面的例子都做了相应的注释大家可以自己写写看看运行的结果。
class person(object): #类的格式
beipiao = '北漂一族' #静态字段：属于类的变量叫做静态字段属于类。
#__init__函数为构造函数，用于初始化动态字段即初始化对象变量
def __init__(self, name,age,addr): #其中self为对象本身，后面的参数为类在实例化传入的参数
#动态字段：属于对象的变量叫做动态字段属于对象
self.name = name #动态字段
self.age = age
self.addr = addr
self.__papapa = True #私有字段 ，不能被外部直接访问
print '(%s: %s)' % (person.beipiao,self.name)
def __del__(self): #析构函数：当对象不再被使用时， __del__ 方法运行
print('最后的话')
def sayHi(self): #类中函数称为动态方法
print 'Hi, my name is %s.' % self.name
@staticmethod #将动态方法转换为静态方法,不用实例化类，直接用类调用静态方法
def chinese(): #不用加self参数，可加其他参数
print('我们都是中国人')
@classmethod
def class_met(cls): #类方法：用类调用，参数只能是cls
print('class method')
def info(self):
print('name:%s age:%s address:%s'%(self.name,self.age,self.addr))
@property #属性：通过装饰器把方法转换成属性：常用作返回值，直接用对象调用方法不用加（）
def car(self):
print ('买不起车')
def __me(self): #私有方法
print('没钱没房没车')
@property #只读
def papapa(self):
return self.__papapa
@papapa.setter #可写
def papapa(self,value):
self.__papapa=value
@papapa.deleter
def papapa(self,value): #删除值
self.__papapa=value
结果展示
lxb = person('小波',23,'河北') #创建对象，就是类的实例化，同时声明变量。
print(lxb.beipiao)# 对象能访问静态字段#print(person.name)#类不能访问动态字段
person.chinese() #类的静态方法
print(lxb.papapa()) #私有字段通过内部公有方法方法展示
print lxb.car #用字段形式访问特性
lxb._person__me() #直接访问私有方法不建议使用
person.chinese() #用类调用静态方法
person.class_met() #用类调用类方法
print lxb.papapa #修改私有字段前结果
lxb.papapa=False #修改私有字段
print(lxb.papapa) #修改私有字段之前的结果

class poor(person):#类的继承
def __init__(self,name,age,addr,buy): #子类增加类变量buy
super(poor,self).__init__(name,age,addr)#调用父类的构造函数,经典类调用方法
person.__init__(self, name,age,addr)#调用父类的构造函数
self.buy=buy
def sayHi(self):
print('%s is a poor')%self.name
结果展示
lxb=poor('小波',23,'河北','cannot')
lxb.car #子类中不存在的方法直接调用，将继承父类的方法
lxb.sayHi() #子类中重新定义的方法，将使用自己的方法

经典类深度优先继承，新式类为广度优先
满足条件，四个类a,b,c,d，其中a为（bc）的基类 ，（bc）继承a ，d继承b，c
class a(): #a不继承任何类为经典类，继承object为新式类。
def f1(self):
print('a.f1')
class b(a):
def f2(self):
print('b.f1')
class c(a):
def f1(self):
print('c.f1')
class d(b,c):
def f2(self):
print('d.f1')
d().f1() 经典类结果为a.f1 #当a类继承object，结果为c.f1

#类的相关方法
class Foo(object):
pass
obj = Foo()
isinstance(obj, Foo) #判断对象是否属于这个类

class Foo(object):
pass
class Bar(Foo):
pass
issubclass(Bar, Foo) #判断一个类是不是另一个类的子类

单例模式，同通俗讲就是类只有一个实例
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。
通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。
如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
例如创建数据库的公共类
class DbHelper(object):
def __init__(self):
self.hostname = '1.1.1.1'
self.port = 3306
self.password = 'pwd'
self.username = 'root'
def fetch(self):
# 连接数据库
# 拼接sql语句
# 操作
pass
def create(self):
# 连接数据库
# 拼接sql语句
# 操作
pass
def remove(self):
# 连接数据库
# 拼接sql语句
# 操作
pass
def modify(self):
# 连接数据库
# 拼接sql语句
# 操作
pass

db = DbHelper()#操作类
db.create()

类的特殊方法：
1、__doc__表示类的描述信息
class Foo:
""" 描述类信息，这是用于看片的神奇 """

def func(self):
pass

print Foo.__doc__
2、__module__ 和 __class__ ：
__module__ 表示当前操作的对象在那个模块，__class__ 表示当前操作的对象的类是什么
3、__call__
对象后面加括号，触发执行。
4、__dict__
类或对象中的所有成员
5、__str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

总结未完，欢迎各种喷！！！