python基础5-面向对象编程

时间：2015-12-11 22:05:03 阅读：367 评论：0 收藏：0 [点我收藏+]

标签：

1.类和对象之封装

#方法1

def Bar():
    print "Bar"
def Hello(name):
    print "i am %s" %(name)

#方法2

class Foo():
    def Bar(self):
        print ‘Bar‘
    def Hello(self,name):
        print "i am %s" %name

对于数据库的增删改查

####方式1

def fetch(hostname,port,username,password,db):
    #1.连接数据库,并且指定hostname、port、username、password、db
    #2.打开数据库
    #3.操作数据库，向数据库添加内容
    #4.关闭数据库
    pass
def modify(hostname,port,username,password,db):
    #1.连接数据库,并且指定hostname、port、username、password、db
    #2.打开数据库
    #3.操作数据库，向数据库添加内容
    #4.关闭数据库
    pass
def remove(hostname,port,username,password,db):
    #1.连接数据库,并且指定hostname、port、username、password、db
    #2.打开数据库
    #3.操作数据库，向数据库添加内容
    #4.关闭数据库
    pass
def create(hostname,port,username,password,db):
    #1.连接数据库,并且指定hostname、port、username、password、db
    #2.打开数据库
    #3.操作数据库，向数据库添加内容
    #4.关闭数据库
    pass
 
 
#将列表添加到数据库
create([11,22,33])

利用函数式编程，每一次都要将hostname、port、username、password、db传进去然后进行操作

####方式2

#封装：就是变一些变量封装到内存地址里面

#下面我们使用类来实现数据库的增删查改

class Foo:
#这个__init__()称为构造方法，当类实例化的时候就执行
#与函数式编程不同：
    ##将hostname、port、username、password、db封装到self变量里面,
    ##当类里面的方法要用到这些参数时，我们直接传self传进去即可，而不用每次1个1个参数传进去
 
    def __init__(self,hostname,port,username,password,db):
        self.hostname = hostname
        self.port = port
        self.username = username
        self.password = password
        self.db = db
    #
    def fetch(self):
        pass
    def remove(self):
        pass
    def create(self):
        pass
    def modify(self):
        pass
 
obj1 = Foo(hostname,port,username,password,db)
obj1 = Foo(1.1.1.1,port,username,password,db)
obj2 = Foo(2.2.2.2,port,username,password,db)
 
obj1.create()
obj1.create()

整个流程：

1.创建Foo类，

（

1.这个步骤包括3步：

1.创建Foo类

2.创建构造函数，将后续要用到的参数封装到self里面；

3.然后创建一系列的方法

）

2.用类Foo创建obj1对象，即将Foo类实例化

（

1.这个过程包括了2步操作：

1.将字段hostname、port、username、password、db_name通过Foo(args)传进去，这些字段就被封装到obj1中；

2.然后创建类对象指针，类对象指针指向内存中的Foo类

）

3.当执行obj.create(self)方法时，即调用obj对象中的create(args)方法，

（

1.这个过程包括2步操作：

1.通过obj对象中的类对象指针找到Foo类中，并调用Foo类中的create()方法

2.返回到obj对象中，取出obj对象中的hostname、port、username、password、db_name字段

3.将取到的这些字段传到类中的create()方法中，执行即可

）

注意：

1.对象只封装字段和类对象指针

2.通过对象来执行类中的方法

2.面向对象之继承

0.怎么使用继承，为什么要使用继承？

#1.方法1

class cat:
    def eat(self):
        pass
    def cry(self):
        pass
    def drink(self):
        pass
    def walk1(self):
        pass
class dog():
    def eat(self):
        pass
    def cry(self):
        pass
    def drink(self):
        pass
    def walk2(self):
        pass

#方法2:

class animal:  #基类
    def eat(self):
        pass
    def cry(self):
        pass
    def drink(self):
        pass
 
class dog(animal):  #派生类，继承父类animal
    def walk2(self):
        pass
 
class cat(animal):  #派生类，继承父类animal
    def walk1(self):
        pass

1.经典类和新式类

##python其实开始只有函数式编程--->然后又有了初级类和对象进行编程--->然后又有了高级类和面向对象编程

*****经典类****** *****新式类*****

经典类：

 class C:
          pass

新式类：

 class C(object):
         pass
  或
  class C(object):
         pass
  class D(C):
        pass

【注意：python3.0只支持新式类，java、c#只能继承1个类，不支持继承多个，而python可以继承多个类】

2.新式类和经典类在多继承中的区别（B、C都继承D）

1.新式类在定义中会在基类或其子类中定义继承object这个类，然而经典类不会定义继承object。

2.新式类在执行多继承，会采用广度优先策略，然而经典类采用深度优先策略。（B、C都继承D才是使用深度优先）

那么什么时候使用面向对象编程呢？

1.多个方法要使用同一个变量或多个变量时采用面向对象编程，即在构造函数中封装

2.当通过模板创建1类东西时才使用面向对象编程

##类成员：实际上就是类里面的方法和字段、属性，统称为类的成员

为什么会定义属性：就是把方法伪造、修饰成1个字段，

#属性与方法的区别：

1.属性在定义时要在上方加装饰器，即@property

2.属性调用时不用加括号，即obj.attribute

3.属性是方法的1种，只是我们对方法进行改造，然后访问调用的时候以字段的形式访问

示例：

class Person(object):
    def __init__(self):
        self.name = name
        self.age = age
 
    def func(self):  #这是定义方法
        return "123"
 
    @property
    def attribute(self):   #这才是定义属性
        return "123"
 
obj = Person(‘jachy‘,21)
obj.attribute  #调用属性
obj.func()   #调用方法

***静态字段和普通字段的区别：

1.静态字段保存在类里面

2.普通字段保存在对象里面

如下图：

示例：

class Person(object):
    name = "jachy"   #这种就是静态字段，保存在类中
    def __init__(self,name,age):
        self.name = name   #这种就是普通字段，保存在对象之中
        self.age = age
 
obj = Person("lilin",21)
obj.name  #访问普通字段 ，通过对象来访问
Person.name  #访问静态字段，通过类来访问

#类方法、静态方法、普通方法

class Province(object):
    def __init__(self):
        pass
    def f1(self):  #定义普通方法，调用时将对象obj赋给self
        pass
    @classmethod   #定义类方法：用classmethod来装饰
    def f2(cls):  #参数用cls而不用self,cls全称是class，调用时将自身Province赋给cls（只能用cls参数）
        pass

#类里面定义静态方法=====函数

   @staticmethod  #定义静态方法，用@staticmethod来修饰
    def f3(arg1,arg2):  #定义静态方法，参数可以随便写
        pass
 
#普通方法的访问
obj=Province()
obj.f1()  #触发者是对象obj
 
#类方法的访问
Province.f2()  #触发者是类Province
 
#静态方法的访问
Province.f3()  #触发者是类Province

类方法和静态方法（他们俩访问时无需创建对象，其调用者是类；而普通方法访问是必须创建对象，其调用者是对象）

1.类方法里面只能传1个参数

2.静态方法相当于是函数

属性（python熟悉用得非常少，因为它不太完善，新式类中才使用属性）

为什么要有属性？为了把方法伪造、“修饰”成1个字段，只能有1个self参数

定义属性的2种表达方式：1.通过装饰器来设置属性；2.直接执行property(func)方法

**********定义属性：方法1***************

class Pager:
    def __init__(self,current_page):
        self.current_page = current_page
        self.per_items = 10
 
    @property
    def start(self):
        val = (current_page - 1) * self.per_items
        return val
 
    @property
    def end(self):
        val = self.current_page * self.per_items
        return val

图1：定义属性的方式1