python 面向对象深入理解

面向过程

函数式编程

面向对象编程：面向对象是由类和对象组成，只要用类和对象实现的，就是面向对象编程

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()

    

    

来自为知笔记(Wiz)