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)

巴特西

python 面向对象深入理解

最新文章

热门文章