python 第六天

面向对象介绍：

1、面向对象有两大特性：

1.1、class:

一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

1.2、object:

一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

class Dog(object):
    def __init__(self,name):  #构造函数，在实例化时做一些类的初始化工作，self是每次实例化d1或者d2那个内存空间，就是实例本身
        self.name = name  #实例变量（静态属性）
    def bulk(self):  #类的方法，功能（动态属性），这里的self也是表示实例化的本身，因为要调用相关的内存空间
        print("%s wang wang wang!" %self.name)

#d1 = Dog("test1")此时self相当于d1,Dog(d1,"test1")
d1 = Dog("test1")   #Dog类的实例，代表吧d1.test1传给了Dog类，这样子self就是d1本身
d2 = Dog("test2")  #生成一个实例，会自动把参数穿个Dog下的__init__(.....)

d1.bulk()  #只有经过实例化后，才能调用类中的方法
d2.bulk()

2、类的3大特性

2.1、封装

在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内容

2.2、继承

一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

class People(object):  
    def __init__(self,name,age):
        self.name = name
        self.age = age

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

    def talk(self):
        print("%s is talking..." %self.name)

    def sleep(self):
        print("%s is sleeping.." %self.name)

class Relation(object):
    def make_friends(self,obj):
        print("%s is making friends with %s " %(self.name,obj.name))
class Man(People,Relation):
　　def __init__(self,name,age,money):
　　　　super(Man,self).__init__(name,age)  #广式继承父类的相关属性，不用自己再声明了，父类已经声明好了
　　　　self.money = money  #父类中没有的属性，再进行声明
　　　　print("%s 一出生就有 %s" %(self.name,self.money))
　　def piao(self):
　　　　print("%s is piaoing ..... 20s... done" %self.name)
　　def sleep(self):   #如果这里有的话，就不会执行父类的方法，这叫重构父类方法
　　　　People.sleep(self) #先继承了父类的方法
　　　　print("man is sleeping")

class Woman(People):  #Woman类完全继承了People中的静态属性，没有对静态属性进行重构
　　def get_birth(self):  #新加了方法
　　　　print(“%s is born a baby” %self.name)

m1 = Man("test1",'18',100000) #必须传入三个参数
m1.eat()  #其实调用了父类的中方法
m1.sleep() #调用的是自己中的方法，只不过继承了父类的方法
w1 = Woman("test2","20")
m1.make_friends(w1)  #因为上边的m1继承了Relation类，make_friends中又传入两个参数，一个是类本身和另一个类
这句话的意思是  make_friends(m1,w1)  这样子就不难理解每次写self意义了，还有就是每次实例化为什么写 m1 = Man()

2.3、多态
简单的说就是一种方法，多种形态，多态的目标是实现一个接口的重复利用

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

    @staticmethod    #静态函数就是和类没有直接关联的，所以animal_talk(self)没用
    def animal_talk(obj):
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)


class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)


# def func(obj):  # 一个接口，多种形态
#     obj.talk()


c1 = Cat('小晴')
c1.talk()   #标准情况下，可以调用类下自己的方法，所以方法里没有任何参数
d1 = Dog('李磊')

Animal.animal_talk(c1)  #静态方法中，因为和类没有直接关系，所以可以传入自己定义的参数
Animal.animal_talk(d1)

3、类的特殊方法：
3.1、静态方法，就是类不能直接调用了自己的函数了，和类没有直接关系了，需要传入相应的参数，上边例子已经有了。
3.2、类方法：类方法只能访问类变量，不能访问实例变量

class Dog(object):
    n = “yun”
    def __init__(self,name):
        self.name = name

    @classmethod
    def eat(self):
        print("%s is eating %s" %(self.n,'flood'))


d = Dog("Test")
d.eat()  #d.eat()中执行的结果是：yun is eating flood,而不是Test is eating flood,因为此方法调用不了实例的参数，只能调类中的yun

3.3、属性方法：
将类中的方法变为类的属性，调用的时候，只能用f.flight_status 而不能用 f.flight_status()

class Flight(object):
    def __init__(self,name):
        self.flight_name = name


    def checking_status(self):
        print("checking flight %s status " % self.flight_name)
        return  1


    @property   #将方法变为属性
    def flight_status(self):
        status = self.checking_status()   #在这里进行调用了方法
        if status == 0 :
            print("flight got canceled...")
        elif status == 1 :
            print("flight is arrived...")
        elif status == 2:
            print("flight has departured already...")
        else:
            print("cannot confirm the flight status...,please check later")

f = Flight("747")
f.flight_status

此时遇到有一个问题，不能对类的属性进行赋值，比如你想f.flight_status = 2，是不允许进行直接赋值的，如果想直接赋值，需要加装饰器：
@flight_status.setter   @flight_status.deleter
如下：

    @flight_status.setter #修改
    def flight_status(self,status):
        status_dic = {
            0 : "canceled",
            1 :"arrived",
            2 : "departured"
        }
        print("33[31;1mHas changed the flight status to 33[0m", status_dic[status])
        #又get到新的技能，字典可以用get方法，status_dic.get()    status_dic.get(status)

    @flight_status.deleter  #删除
    def flight_status(self):
        print("status got removed...")

f = Flight("CF747")
f.flight_status
f.flight_status = 2
del f.flight_status
f.flight_status

3.4、反射：通过字符串映射或修改程序运行时的状态、属性、方法, 有以下4个方法
# #### 检查是否含有成员 #### 
hasattr(obj, 'name') hasattr(obj, 'func') 

# #### 获取成员 #### 
getattr(obj, 'name') getattr(obj, 'func') 

# #### 设置成员 #### 
setattr(obj, 'age', 18) setattr(obj, 'show', lambda num: num + 1) 

# #### 删除成员 ####
 delattr(obj, 'name') delattr(obj, 'func')

def bulk(self):
    print("%s is yelling..." %self.name)
class Dog(object):
    def __init__(self,name):
        self.name = name

    def eat(self,food):
        print("%s is eating..."%self.name,food)



d = Dog("NiuHanYang")
choice = input(">>:").strip()   #此处



if hasattr(d,choice):     #假如有这个属性
    delattr(d,choice)  #删除方法需要输入eat()
    fun = getattr(d,choice)  #输入的是eat,choice就是eat中的food这个参数,这是对方法的处理
    fun("2018")  #赋值的相当于是eat中的food
    attr = getattr(d,choice)
    setattr(d,choice,"33")   #这是对类中的属性进行修改
    print(d.age)
else:
    setattr(d,choice,bulk)  #把外部的函数装到类里边,此时bulk会变成choice中输入的字符，比如输入talk
    d.talk(d)
    # setattr(d,choice,22)  #动态属性的添加
    # print(getattr(d,choice))

# print(d.name)

4、异常处理
在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面。

def bulk(self):
    print("%s is yelling..." %self.name)
class Dog(object):
    def __init__(self,name):
        self.name = name

    def eat(self,food):
        print("%s is eating..."%self.name,food)



# d = Dog("NiuHanYang")
# choice = input(">>:").strip()
# getattr(d,choice)

data = {}
names = [1,2]

try:   #程序正常就正常执行
    # names[3]
    # data['name']
    open("tes.txt")
    # a = 1
    # print(a)
# except Exception as e:
#     print("出错了",e)
except (KeyError,IndexError) as e:  #具体的错误类型
    print("没有这个key",e)
except IndexError as e:
    print("列表操作错误",e)
except Exception as e:  #不管是什么错误类型
    print("未知错误",e)
else:  # #主代码块执行完，执行该块
    print("一切正常")
finally:  # 无论异常与否，最终执行该块
    print("不管有没有错都执行")