面向对象，类

#-*- coding:utf-8 -*-
class Dog(object):
    a=123              #类变量
    def __init__(self,name):            #此为构造函数 ，实例化时自动执行执行此方法，做初始化工作
        self.name=name  #实例变量
        print self.name
        a=333
        print a
    def bulk(self):
        print ('%s wang wang')%self.name
    def __del__(self):                          #此为析构函数，在程序执行完毕，自动执行析构函数
        print ('执行完毕，实例狗狗被销毁')
    print a
D1=Dog('HAHA')
D2=Dog('huahua')

D1.bulk()
D2.bulk()
print Dog
print D1
print D2

以上这个程序，先解析此程序，把类，类内部的init和bulk方法进行解析，存入内存中，
然后执行D1=Dog('HAHA')，就是实例化D1，把实例参数传入init方法中，自动执行此方法，
也就是说，实例化时，init函数是自动触发执行的，执行完，后执行D2=Dog('huahua')，
然后再执行init，接着执行D1.bulk()，调用bulk方法，然后是D2.bulk()，再调用bulk

class people(object):      #基类
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def eat(self):
        print (('一个叫%s的%s性%s岁的人在吃饭') % (self.name, self.sex, self.age))
    def sleep(self):
        print (('一个叫%s的%s性%s岁的人在睡觉') % (self.name, self.sex, self.age))

class man(people):           #子类
    def yan(self):          #子类会继承父类的所以属性和方法，子类在父类基础上进行方法yan扩充，
        print (('一个叫%s的%s性%s岁的人在吸烟') % (self.name, self.sex, self.age))

    def sleep(self):        #子类可以重构父类里面的方法，此对父类的sleep方法进行了扩充
        people.sleep(self)
        print ('每晚都会打呼噜')

class woman(people):    #子类
    def __init__(self,name,age,sex,shop):     #子类可以增加参数，在继承父类的构造方法后，对其进行扩充
        super(woman,self).__init__(name,age,sex)
        self.shop=shop
    def shopping(self):
        print (('一个叫%s的%s性%s岁的人在%s') % (self.name, self.sex, self.age,self.shop))

peo1=people('chenna',24,'女')
peo1.sleep()
man1=man('xiaoming',22,'男')
man1.piao()
man1.sleep()
woman1=woman('chenna',24,'女','买菜')
woman1.shopping()

class p1(object):
    def foo(self):
        print 'in the p1-foo'

class p2(object):
    def foo(self):
        print 'in the p2-foo'
    def bar(self):
        print 'in the p2-bar'

class c1(p1,p2):
    pass

class c2(p1,p2):
    def bar(self):
        print 'in the c2-bar'

class gc (c1,c2):
    pass

gcc=gc()
gcc.foo()
gcc.bar()
print gc.__mro__  #显示查找顺序
#新式类采用从左到右的广度优先查找，

 旧式类采用深度优先的算法查找，

旧式类采用广度优先的算法查找，

 三种重要方法：静态方法，类方法，属性方法

class Dog(object):
    def __init__(self,name):
        self.name= name
    @staticmethod          #吧类里面定义的动态方法eat变成了静态方法，切断了eat方法和类之间的联系，类无法自动给方法传参
    def eat(self,food):
        print ('%s is eating %s'%(self.name,food))

d=Dog('HAHA')
#d.eat('骨头')
#TypeError: eat() takes exactly 2 arguments (1 given),
# 也就是此时，类没有自动给调用的方法eat传递self的参数（即没d传给eat的self）

d.eat(d,'骨头')#这里手动吧参数传了进去
'''
'''
class Dog(object):
    n=333
    def __init__(self,name):
        self.name=name
        self.n=222
    @classmethod    #通过此装饰，使类里面的方法eat变成类方法
    def eat(cls):
        print ('%s is eating %s'%(cls.n,'dd'))
d=Dog('haha')
d.eat()
#类方法：只能访问类变量，不能访问实例变量，变成类方法后，self被cls代替，一定要注意书写


class Dog (object):
    def __init__(self,name):
        self.name=name
    @property
    def eat(self,food):
        print ('%s is eating %s'%(self.name,food))
d=Dog('haha')
d.eat('gutou')
#TypeError: eat() takes exactly 2 arguments (1 given),类没有自动把self的值传给eat方法
属性方法：通过@property,把一个类里面的方法eat变成了属性方法，就是把它变成了静态属性，
所以不能通过加（）来调用，这样的话就带来了一个问题：如何在调用此方法，给它传参数。

class Dog (object):
    def __init__(self,name):
        self.name=name
    @property
    def eat(self):
        print ('%s is eating %s'%(self.name,self.__food))

    @eat.setter
    def eat(self,food):
        print ('set to food :',food)
        self.__food =food
    @eat.deleter
    def eat (self):
        del self.__food   

d=Dog('haha')
d.eat
上部分代码出错？？？？？？？？？？？？？？？

反射：hasattr,getattr,setattr,delattr四个函数
hasattr(obj,name_str):判断一个对象obj里面是否有对应得name_str字符串，（返回T,F）
getattr(obj,name_str):根据字符串去获取obj对象里面的对应得方法的内存地址
setattr(obj,nama_str,value),setattr()将要么加入一个属性，要么取代一个已经存在的属性。相当obj.name_str =value
delattr(）从一个对象中删除一个属性

def bulk():
    print 'wang wang wang'

class Dog (object):
    def __init__(self,name):
        self.name=name
    def eat(self,food):
        print('%s is eating %s'%(self.name,food))

d=Dog('haha')         #实例化一个对象d
choice=raw_input('>>>:').strip()
if hasattr(d,choice):      #这里判断的是实例对象里是否存在 名字为choicezi字符串的方法
    func=getattr(d,choice)  #若存在，通过getattr 把实例的这个choice方法的内存地址赋值给func
    func('gutou')          #func（）来调用实例对象里的此方法
else:
    setattr(d, choice,bulk)#如果不存在，就在实例中加入一个属性bulk,这里只是加入了这个属性
                            #可以通过print dir(d)来查看，属性是否存在
    func = getattr(d, choice)  #在这一步，是在吧加入的新的属性的内存地址赋值给func,然后就可以调用了
    func()      #并没有传参数d,但运行正常？？？？？




class myclass(object):
    def __init__(self):
        self.foo=100
myinst=myclass()
print hasattr(myinst,'foo')
a=getattr(myinst,'foo')  #这里foo字符串在实例myinst里是一个变量名，getattr(myinst,'foo')
                         # 就是把此次变量的值赋值给a,如果不是变量，而是实例的一个方法，
                         #就是把此方法的内存地址赋值给a
print a

print hasattr(myinst,'bar')
#b=getattr(myinst,'bar')     #AttributeError: 'myclass' object has no attribute 'bar'
#print b
print setattr(myinst,'bar',None) #等同于myinst.bar=None
print dir(myinst)         #返回 'bar', 'foo'

delattr(myinst,'bar')
print dir(myinst)        #返回'foo'
'''