python之面向对象

面向对象与面向过程：

举个例子：

加入要去吃烤鱼，

面向过程：自己动手，从买鱼，洗鱼洗菜，烤鱼，加调料等..　　　　　　　　　　　　　　　　　　　　　　　　　　　　

面向对象：来到烤鱼店，店菜单，吃，结账走人

所以总结如下：

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

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

面向对象：对函数进行分类和封装，让开发速度更快

一. 创建类和对象

　　　在python中，用变量去表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是"类"，对象则是这一类事物中具体的一个

　　1.1 类的作用：属性引用和实例化

　　如以下代码：

class Person:    # 定义一个类class
    couty = "china"   # 类属性，静态属性

    def __init__(self, *args): # 
        # self 类似于一个字典   
        print(self.__dict__) # {}
        self.name=name   #  

    def walk(self):
        print("zou")

print(Person.couty)    # 查看类的属性
print(Person.walk)　　　# 查看类的方法

属性引用（类名.属性）

实例化：类名加括号，会触发_init_函数的运行，可以用它来为每个实例定制自己的特征

实例化的过程就是类----》对象的过程

语法：对象名=类名（参数）

egg = Person('xiaohei')  #类名()就等于在执行Person.__init__()
#执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。

查看属性&调用方法：　

print(egg.name)   # 查看属性  对象名.属性名
print(egg.walk())    # 调用方法：对象名.方法名（）

关于self：在实例化时自动将对象/实例本身传给_init_的第一个参数，可以起和别的名字，但正常人都不会这么改的

　　1.2 对象：

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;

    def attack(self,dog):  
        # 人可以发起攻击，这里被攻击的也是一个对象
        dog.life_value -= self.aggressivity

　　对象是关于类而实际存在的一个例子，即实例　　

　　对象/实例只有一种作用：属性引用

xiaohei = Person('xiaohei',10,1000)  # 根据类Person创建对象xiaohei
print(xiaohei.name)                  
print(xiaohei.aggressivity)
print(xiaohei.life_value)

　　引用动态属性

print(egg.attack)

面向对象的固定模式

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

二. 面向对象三大特性

1.封装

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

# 创建类
class Boo:
    def __init__(self, name, age):  # 构造方法，根据类创建对象时自动执行4
        self.name = name
        self.age = age

    # 通过self间接调用被封装的内容
    def datail(self):
        print(self.name)
        print(self.age)


# 根据类Boo创建对象
# 自动执行Boo类的_init_方法
obj1 = Boo("xiaohei", 18)  # 将xiaohei和18分别封装到obj的name和age属性中
# print(obj1.name)          # 调用obj1对象的name属性
# print(obj1.age)           # 调用obj1对象的age属性

obj1.datail()  ## Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

obj2 = Boo("xiaoming", 20)
# print(obj2.name)
# print(obj2.age)
obj2.datail() 

2.继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容，将多个类共有的方法提取到父类中，子类仅需继承父类而不必实现每个方法

class Animal:

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

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

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

    def pee(self):
        print("%s 撒 " % self.name)


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print('喵喵叫')


class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '狗'

    def cry(self):
        print('汪汪叫')


# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

打印结果如下：

class 父类:
    def 父类中的方法(self):
        pass


class 子类(父类):  # 子类继承父类，即拥有了父类的所有方法
    pass


zilei = 子类()  # 创建子类对象
zilei.父类中的方法()  # 执行从父类中继承的方法

2.1多继承

python中类可以继承多个类，java和C#只能继承一个类

python的类如果继承多个类，寻找的方法有两种，分别是深度优先和广度优先

• 当类是经典类时，多继承情况下，会按照深度优先方式查找      A---->B---->D----->C
• 当类是新式类时，多继承情况下，会按照广度优先方式查找　  A----->B---->C----->D

                          

 3.多态

　　多态的概念是用于Jave和C#语言上的，而python则崇尚"鸭子类型"

　　所谓多态：定义时的类型和运行时的类型不一样，此时就是多态

　　python伪代码实现Java或C#的多态

class F1(object):
    def show(self):
        print 'F1.show'

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

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

# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""

    print obj.show()

s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

python的"鸭子类型"

鸭子类型：函数/方法可以接受一个任意类型的对象作为参数/返回值，只要该对象实现了代码后续用到的属性和方法就不会报错

代码如下：

class F1(object):
    def show(self):
        print 'F1.show'

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)