#-*- 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方法
屬性方法：[email protected],把一個類裏面的方法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‘
‘‘‘

面向對象，類