面向过程函数式编程
面向对象编程：面向对象是由类和对象组成，只要用类和对象实现的，就是面向对象编程
def Bar():
print "This is Bar "
def Hello(name):
print "Iam is %s " % name
class Foo():
print "Iam is %s " % name
python面向的对象种类：继承，封装，多态
python语言中的多态表现并不是很突出，主要是继承和封装
方式一：
def fetch():
#连接数据库，hostname,port,password,db
#打开数据库
#操作数据库
#关闭数据库
def modify():
#连接数据库，hostname,port,password,db
#打开数据库
#操作数据库
#关闭数据库
def remove():
#连接数据库，hostname,port,password,db
#打开数据库
#操作数据库
#关闭数据库
def create():
#连接数据库，hostname,port,password,db
#打开数据库
#操作数据库
#关闭数据库
函数调用执行： （看起来比较复杂）
create(hostname,port,passpord,db)
remove(hostname,port,passpord,db)
modify(hostname,port,passpord,db)
fetch(hostname,port,passpord,db)
面向对象：
class Foo():
def __init__(self,hostname,port,password,db):
self.hostname = hostname
self.port = port
self.passpord = password
self.db = db
def fetch(self):
self.hostname
self.port
self.passpord
self.db
def modify(self):
pass
def create(self):
pas
def remove(self):
pass
obj = Foo(127.0.0.1,3306,123456,testdb)
obj.fetch() #这里就不需要传入参数了，直接调用即可
先把类读入到内存中，在内存里面就有了很多方法 （包括init，modify，fetch，remove，create）
如果创建对象内存里就只有这些东西，创建一个obj = Foo()对象，相当于把obj赋值给了self，self就等同于obj
此时hostname=127.0.0.1 port=3306 passpord=123456 db=testdb 保存在self里面,在self内存中存放
类对象指针，指针指向了类，相当于做了一个关联，obj是根据类Foo创建的，每个对象都有一个创建它的类
obj通过指针找到了类，从而在类中找到类中的方法，进行执行和调用
对象是由类来创建的，对象只封装字段
对象执行的时候，如果用到变量就需要去对象封装的变量中去找
对象的创建如何用？
根据一个模板来动态得创建一个东西
如果多个方法，方法共用一个变量，通过构造函数，封装起来，对象里执行的时候，通过构造函数来执行
新式类： 只要在定义类的时候class Foo(object) 有这个object就代表是新式类
类的继承
父类的功能，子类都可以继承
class linux():
def kernel(self):
print "my kernel is 4.0"
class ubuntu(linux): #继承的父类
def xubunu(self):
print “Iam si xubuntu”
os = ubuntu()
os.kernel
#不管是直接的还是间接地继承，父类的功能都是可以使用的
现在的通常叫法：
父类也叫：基类
子类也叫：派生类
类的多继承
新式类遵循广度优先
经典类遵循深度优先
多继承的深度优先和广度优先 如图：
class D():
def bar(self):
print "D"
class B(D):
pass
class C(D):
pass
class A(B,C)
类和对象分别都有什么？
类里面有方法
对象里面有字段
classs Person():
def __init__(self,name,age):
self.name = name
self.age = age
def func(self):
return "ok"
在一个类中有三种类成员 字段 方法 属性
字段 ：
普通字段
class os(object):
def __init__(self,name):
self.name = name #普通字段
不同的对象调用相同的方法时，方法中引用普通字段
静态字段：
class os(object)
kernel = "linux" #静态字段
def __init__(self,name):
self.name = name
centos = os(‘centos’)
centos.kernel #
print os.kernel #建议用这个形式
不同的对象调用相同的字段
所有对象都可以访问静态字段，可以看作为是每个对象具有共同的属性
方法：
普通方法
对象执行一个方法的时候， 自动把自己当做一个参数，赋值给self，参数至少要一个self
静态方法
可以直接传入一个参数，相当于函数的动态传参
类方法
同理，类会自动把自己当做一个参数，赋值给方法的cls
如果向执行一个方法，可以直接调用，不需要在创建对象，然后用对象调用方法，而是可以直接通过类来调用
class os():
def f1(self): #普通方法
pass
@staticmethod #静态方法
def f2(cls):
print cls
@classmethod #类方法
def f3(arg):
pass
属性：
python中的属性用的非常少
不管是新式类和经典类都可以加载property
属性在定义的时候，仅有一个self 参数，在方法上加上@property，执行的时候不需要加上() ---> obj.func2 如下:
classs Person():
def __init__(self,name,age):
self.name = name
self.age = age
def func(self):
return "ok"
@property
def func2(self):
return("Iam is ok ")
obj = Person("budongshu","18")
obj.func() #普通方法执行方式
obj.func2 #属性执行方式
属性的好处：
为了伪造成一个属性，也可以说是伪造成一个字段，一个假象，让你知道它是一个属性，访问执行的时候不需要加上括号
属性的另外一种定义形式：
def func2(self):
return("Iam is ok ")
bar = property(func2)
只有新式类生效的属性方法：
@property.setter
def func2(self):
return("Iam is ok ")
执行同上个例子：obj.func2 = "not ok"
@property.deleter
def func2(self):
return("Iam is ok ")
执行通上个例子：del obj.func2
成员修饰符 公有和私有
其他语言比python的功能要多，私有和共有都有受保护的功能
公有
class os(object):
kernel = "linux" #正常来说，平时定义的代码，都是公有的
def start():
print os.__kernel
os.kernel #成功调用
私有
直接访问是访问不到私有字段的，但可以通过类的内部方法和属性都可以间接地访问到
私有字段
class os(object):
__kernel = "linux" #前面加俩个下划线就变成了私有
def start():
print os.__kernel
os.kernel #这时候调用的时候，就会报错
centos = os()
centos.start()
def __init__(self):
_self__name = name #私有字段只有内部访问
私有方法
def __start(self):
pass
@staicmethod
def __start(self):
pass
思考：类的继承可以访问私有的吗？
答： 是不可以的，子类也是访问不了的
class windows(os):
def show(self):
print os.__kernel
特殊情况 ： 不推荐使用，但也可以使用
centos._os__kernel
centos._os__name
centos._os__start()
python 面向对象深入理解
原文：http://www.cnblogs.com/budongshu/p/3cb988ba8ab40a1422ec34fa8b092e98.html
