python笔记 第十一天 面向对象

概述    

    面向过程：根据业务逻辑从上到下写垒代码

    函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

    面向对象：对函数进行分类和封装，让开发“更快更好更强...”

类的定义

类定义，像函数定义一样，在执行时才会起作用。你可以把类定义放在任何地方比如if语句的分支，或者在函数内部。 在实际应用时，定义在类中的语句通常都是函数定义，但是其它语句也是允许出现的，并且有的时候非常有用。 当进入一个类定义时，一个新的名称空间被创建，并且被当作局部域来使用。

类的书写格式

关键字为：class 

创建对象，类名称后加括号即可

注：执行方法必须是  obj = foo()  创建一个对象   再用对象执行内方法，如：ret = obj.start()

class line:
    def __init__(self, data):#构造方法
        try:
            p = int(data)
        except Exception as e:
            p = 1
        self.p = int(p)

    def start(self):#方法
        ret = (self.p - 1) * 10
        return ret

    def end(self):#方法
        ret = self.p * 10
        return ret

特殊方法*

    构造方法

     __init__，默认对象调用类的时候，会执行init方法，创建基础值，

class game:
    foo =  100#字段
    blue = 100
    sjjy = 100
    money = 0
    def __init__(self, name, sex="男"):#创建基础信息
        '''
        构造方法 创建人物信息
        :param name:
        :param sex:
        '''
        self.name = name  # 昵名
        self.sex = sex  # 性别
        self.leves = 1  # 等级
        self.gjl = 10  # 攻击力
        self.foo = 100  # 血
        self.foosj = 100  # 升级后的最大血量
        self.blue = 100  # 蓝
        self.bluesj = 100  # 升级后最大蓝量
        self.jinyan = 0  # 当前经验值
        self.sjjy = 100  # 升级所需要的经验
        self.money = 0  # 用户金额

#本段代码来自 海瑞博客http://www.hairuinet.com/post/44.html

       注：obj = 类（）就会执行构造方法

三大特性

    1.封装

        封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

        所以，在使用面向对象的封装特性时，需要：将内容封装到某处，使用时从某处调用被封装的内容

    直接调用案例：

class foo:
    def __init__(self,name,age,sex="男"):
        self.name = name
        self.age = age
        self.sex = sex

obj1 = foo("hairui",25)
#执行时，self 就是obj1
obj2 = foo("zjw",20)
#执行时，self 就是obj2

print("obj1的姓名：%s,年龄:%s,性别：%s"%(obj1.name,obj1.age,obj1.sex))
print("obj2的姓名：%s,年龄:%s,性别：%s"%(obj2.name,obj2.age,obj2.sex))
#obj1的姓名：hairui,年龄:25,性别：男
#obj2的姓名：zjw,年龄:20,性别：男

class foo:
    def __init__(self,name,age,sex="男"):
        self.name = name
        self.age = age
        self.sex = sex
    def show(self):
        print("%s的姓名：%s,年龄:%s,性别：%s"%(self,self.name,self.age,self.sex))

obj1 = foo("hairui",25)
#执行时，self 就是obj1
obj2 = foo("zjw",20)
#执行时，self 就是obj2

obj1.show()
obj2.show()
# <__main__.foo object at 0x102185320>的姓名：hairui,年龄:25,性别：男
# <__main__.foo object at 0x102185358>的姓名：zjw,年龄:20,性别：男

     综上所述，对于封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

    2.继承

            1.继承父类，子承父业

            案例：

            　　猫可以：喵喵叫、吃、喝、拉、撒

            　　狗可以：汪汪叫、吃、喝、拉、撒

class zoon:
    def eat(self):
        print("%s吃粮" % self.name)

    def drink(self):
        print("%s喝水" % self.name)

    def la(self):
        print("%s拉set" % self.name)

    def sha(self):
        print("%s潵野" % self.name)


class cat(zoon):
    def __init__(self,name):
        self.name = name
    def cry(self):
        print("%s喵喵叫" % self.name)


class dog(zoon):
    def __init__(self,name):
        self.name = name

    def cry(self):
        print("%s汪汪叫" % self.name)


cat1 = cat("二黑")
cat1.drink()
cat1.cry()
dog1 = dog("旺旺")
dog1.drink()
dog1.cry()

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

        2.重写

class f:
    def f1(self):
        print("i am f1")

    def f2(self):
        print("i am f2")

class s(f):#继承
    def s1(self):
        print("i am s1")

    def f2(self):#重写父类方法
        super(s,self).f2()#推荐使用。使用父类的方法
        print("i am s.f2")
        f.f2(self)#使用父类的方法

obj = s()
obj.s1()
obj.f2()

super(派生类,self).基类方法(）派生类方法中使用基类方法，推荐使用，可读性强

基类.基类方法(派生类的self) 同上，不推荐使用

    3.多继承

        Python的类可以继承多个类，Java和C#中则只能继承一个类

        Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

        

        当类是经典类时，多继承情况下，会按照深度优先方式查找

        当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类

class D:

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

经典类多继承

新式类

class D(object):

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

新式类多继承

     3.多态

Python 原生就是多态，无须关注过多

崇尚鸭子类型

class F1:
    pass

class S1(F1):

    def show(self):
        print 'S1.show'

class S2(F1):

    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj) 

Python “鸭子类型”