# coding = utf-8

###############################################################################

# 1.構(gòu)造函數(shù)
# 構(gòu)造函數(shù)就是初始化方法枚碗，不同普通方法，它在對象創(chuàng)建后會自動調(diào)用__init__
class FooBar:
    def __init__(self):
        self.somevar = 42

f = FooBar()
print(f.somevar)
print()

# 可給構(gòu)造函數(shù)提供參數(shù)
class FooBar2:
    def __init__(self, value=42):
        self.somevar = value

f2 = FooBar2()
print(f2.somevar)
print()

f3 = FooBar2('Tana')
print(f3.somevar)
print()

# Python提供了魔法方法__del__,也稱為析構(gòu)函數(shù)赠尾，它在對象被銷毀（作為垃圾被收集）前調(diào)用~

class FooBar3:
    def __init__(self, value=42):
        self.someval = value
    def __del__(self):
        print('銷毀啦')

f4 = FooBar3('Joe')
f4 = None
print()


###############################################################################
# 1.1 重寫普通方法和特殊的構(gòu)造函數(shù)
# 每個類都有一個或多個超類缭召，并從它們那里繼承行為澜掩。對類B的實例調(diào)用方法（或訪問其屬性時），
# 如果找不到該方法或?qū)傩?將從其超類A中查找，

class A:
    def hello(self):
        print("Hello,I'm A")
class B(A):
    pass

a = A()
b = B()
a.hello() # Hello,I'm A
b.hello() # Hello,I'm A
print()

class B(A):
    def hello(self):
        print("Hello,I'm B")

a = A()
b = B()
a.hello() # Hello,I'm A
b.hello() # Hello,I'm B
print()

# 構(gòu)造函數(shù)用于初始化新建對象的狀態(tài)枉昏，而對于大多數(shù)子類而言干花，除了超類的初始化代碼外妄帘，
# 還要有自己的初始化代碼。雖然所有方法的重寫機(jī)制都相同池凄，但與普通方法重寫相比抡驼，
# 重寫構(gòu)造函數(shù)時可能會遇到一個特別的問題：重寫構(gòu)造函數(shù)必須調(diào)用超類的構(gòu)造函數(shù)，否則可能無法正確的初始化對象

class Bird:
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print("Aaaaa....")
            self.hungry =False
        else:
            print('No, thanks')

b = Bird()
b.eat() # Aaaaa
b.eat() # No, thanks
print()

class SongBird(Bird):
    def __init__(self):
        self.sound = 'Squawk'
    def sing(self):
        print(self.sound)

sb = SongBird()
sb.sing()
print()

# sb.eat() #AttributeError: 'SongBird' object has no attribute 'hungry' 報錯
# SongBird 沒有屬性hungry肿仑，因為在SongBird中重寫了構(gòu)造函數(shù)致盟，但新的構(gòu)造函數(shù)沒有初始化屬性hungry的代碼
# 有兩種方式可以解決：調(diào)用未關(guān)聯(lián)的超類構(gòu)造函數(shù) 或 使用函數(shù)super


# 1.2 調(diào)用未關(guān)聯(lián)的超類構(gòu)造函數(shù)
# 類名.__init__(self)

class SongBird(Bird):
    def __init__(self):
        Bird.__init__(self)
        self.sound = 'Squawk'
    def sing(self):
        print(self.sound)

sb = SongBird()
sb.eat()
print()

# 對實例調(diào)用方法時，方法的參數(shù)self會自動關(guān)聯(lián)到實例（稱為關(guān)聯(lián)的方法）
# 但如果對類調(diào)用方法（例如Bird.__init__(self)）時,由于沒有實例與其關(guān)聯(lián)尤慰，可隨便設(shè)置self馏锡，這樣的方法被稱為未關(guān)聯(lián)的


# 1.3 使用函數(shù)super
# super().__init__()
# 調(diào)用函數(shù)super時，會將當(dāng)前類和當(dāng)前實例作為參數(shù)伟端。對其返回的對象調(diào)用方法時杯道，調(diào)用的將是超類（不是當(dāng)前類）的方法

class Bird:
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print("Aaaaa....")
            self.hungry =False
        else:
            print('No, thanks')

class SongBird(Bird):
    def __init__(self):
        super().__init__()
        self.sound = 'Squawk'
    def sing(self):
        print(self.sound)

sb = SongBird()
sb.sing()
sb.eat()
print()

# 函數(shù)super返回的是一個super對象，這個對象將負(fù)責(zé)為你執(zhí)行方法解析责蝠。
# 當(dāng)你它的屬性時党巾，它將在所有的超類（以及超類的超類）中查找，直到找到指定的屬性或引發(fā)AttributeError



###############################################################################
# 2. 元素訪問
# 協(xié)議 協(xié)議通常是指規(guī)范行為的規(guī)則
# 在python中霜医，多態(tài)僅僅基于對象的行為（而不是基于祖先昧港，如屬于哪個類或超類）
# 在其他語言中可能要求對象屬于特定的類或?qū)崿F(xiàn)了特定的接口。而Python通常只要求對象遵循特定的協(xié)議支子。
# 因此创肥，要成為序列，只需遵循序列協(xié)議即可、


# 2.1 基本的序列和映射協(xié)議
# 序列和映射基本上是元素的集合叹侄，要實現(xiàn)他們的基本行為（協(xié)議）巩搏，不可變對象需實現(xiàn)2個方法，可變對象需要實現(xiàn)4個方法
# ① __len__(self):這個方法應(yīng)返回集合包含的項數(shù)趾代，對序列而言就是元素個數(shù)贯底，對字典而言就是鍵值對的個數(shù)
#    如果__len__返回零（且沒有實現(xiàn)覆蓋這種行為的__nonzero__）,對象在布爾上下文中視為假（就像空列表 空元組 空字典）
# ② __getitem__(self,key):這個方法返回與指定鍵相關(guān)聯(lián)的值。對序列而言撒强，鍵就是0~n-1的整數(shù)（也可以為負(fù)數(shù)）禽捆，
#    對字典而言，鍵可以是任意類型
# ③ __setitem__(self,name,value):這個方法應(yīng)以與鍵相關(guān)聯(lián)的方式儲值飘哨。以便以后可以通過__getitem__來獲取
#    僅當(dāng)對象可變時胚想，這個方法才需要實現(xiàn)
# ④ __delitem__(self,key): 這個方法在對對象的組成部分使用__del__語句時調(diào)用，應(yīng)刪除與key相關(guān)聯(lián)的值
#    僅當(dāng)對象可變且允許其刪除時芽隆，這個方法才需要實現(xiàn)

# 對于這些方法浊服，還有一些額外的要求
# ①對于序列，鍵可以為負(fù)數(shù)胚吁，應(yīng)從末尾往前數(shù)牙躺，即x[-n] = x[len(x)-n]
# ②如果鍵的類型不合適（如對序列使用字符串鍵），可能引發(fā)TypeError
# ③對于序列腕扶，如果所用的鍵類型正確但不在允許范圍內(nèi)孽拷，應(yīng)引發(fā)IndexError異常


# 自定義無窮序列
# 思考：
# ① 由于是無窮序列，鍵應(yīng)該是非負(fù)整數(shù)半抱，如果為負(fù)數(shù)脓恕，應(yīng)引發(fā)IndexError 如果鍵不是整數(shù)應(yīng)引發(fā)TypeError
# ② 由于是無窮序列，鍵相關(guān)的值應(yīng)該是動態(tài)計算的 __getitem__  self.start + self.step * key
# ③ 應(yīng)設(shè)置一個change字典去存儲 修改后的值 __setitem__

# 檢查鍵key是否正確
def check_index(key):
    """
    由于是無窮序列代虾，鍵應(yīng)該是非負(fù)整數(shù)进肯，
    如果為負(fù)數(shù)激蹲，應(yīng)引發(fā)IndexError
    如果鍵不是整數(shù)應(yīng)引發(fā)TypeError

    """
    if not isinstance(key, int):raise TypeError
    if key < 0:raise IndexError


class ArithmeticSequence:
    def __init__(self, start=0, step=1):
        """
        :param start: 序列中的第一個值
        :param step: 兩個相鄰值得差
        changed 一個字典棉磨，存儲修改后的值
        """
        self.start = start
        self.step = step
        self.changed = {}

    def __getitem__(self, key):
        '''

        從算數(shù)序列中獲取一個元素

        '''

        check_index(key)

        try:
            return self.changed[key] # 如果沒被修改過，key會不存在 會引發(fā)KeyError錯誤
        except KeyError:
            return self.start+key*self.step

    def __setitem__(self, key, value):
        '''

        修改序列中的元素

        '''
        check_index(key)

        self.changed[key] = value

s = ArithmeticSequence(1,2)
print(s[4])
s[4] = 2
print(s[4])
# print(s[-1])  #IndexError
# print(s['A']) #TypeError
print()


# 2.2 從list dict str派生

# 帶訪問計數(shù)器的列表

class CounterList(list):
    def __init__(self, *args):
        super().__init__(*args)
        self.counter = 0

    def __getitem__(self, item):
        self.counter +=1
        return super(CounterList, self).__getitem__(item)

# CounterList類繼承于其超類list学辱，CounterList沒有重寫的方法（如append extend index等）都可以直接調(diào)用
# 在兩個被重寫的方法中乘瓤，使用super來調(diào)用超類的相應(yīng)方法，并添加了必要的行為：
# 初始化屬性counter（在__init__）和更新屬性counter（在__getitem__中）

c1 = CounterList(range(10))
print(c1)
c1.reverse()
print(c1)
c1[4] + c1[2]
print(c1.counter)
print()


# 重寫__getitem__并不能保證一定會捕捉用戶的訪問操作策泣，因為還有其他訪問列表的操作沒有捕捉到衙傀，如通過方法pop

print(c1.pop())
print(c1.counter)
print()


###############################################################################

# 3. 特性
# 存取方法
# 如果訪問給定屬性時必須采取特定的措施，可以通過存取方法來封裝狀態(tài)變量（屬性）

class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0
    def set_size(self, size):
        self.width , self.height = size
    def get_size(self):
        return self.width, self.height

r = Rectangle()
r.width = 20
r.height =10
print(r.get_size())
print()

r.set_size((10, 20))
print(r.width)
print()


# get_size 和set_size 是假想屬性的size的存取方法萨咕，這個屬性是由width和height組成的元組统抬。
# 但存在一個缺陷：如果要讓size稱為真正的屬性（r.size），而width和height是動態(tài)計算出來的，
# 就需要提供width聪建，height的存取方法 這個類就要重寫
# 函數(shù)property可以隱藏存取方法



# 3.1 函數(shù)property

class Rectangle():
    def __init__(self):
        self.width = 0
        self.height = 0
    def set_size(self, size):
        self.width, self.height = size
    def get_size(self):
        return self.width, self.height
    size = property(get_size,set_size)

r = Rectangle()
r.width = 10
r.height =15
print(r.size)
print()

# 通過調(diào)用函數(shù)property钙畔，并將存取方法作參數(shù)（獲取方法在前，設(shè)置方法在后）創(chuàng)建了一個特性金麸，
# 然后將名稱size關(guān)聯(lián)到這個特性擎析，這樣就可以以同樣的方法訪問width height size了

# 函數(shù)property 有4個參數(shù)
# 如果沒有指定任何參數(shù)，創(chuàng)建的特性既不可讀也不可寫挥下，
# 如果只指定一個參數(shù)（獲取方法）揍魂，則創(chuàng)建的特性只可讀
# 第三個參數(shù)是可選，指定用于刪除屬性的方法（這個方法不接受任何參數(shù)）
# 第四個參數(shù)也是可選棚瘟，指定一個字符串文檔现斋。
# 這些參數(shù)分別名為fget fset fdel doc
# 如果你要創(chuàng)建一個只可寫且?guī)臋n字符串的特性，可使用它們作為關(guān)鍵字參數(shù)來實現(xiàn)

class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0
    def get_size(self):
        return self.width, self.height
    def doc(self):
        print("HHHHHHH")
    # 只可讀 不可寫
    size = property(fget= get_size, doc=doc)

r = Rectangle()
r.width =16
r.height =20
# r.size =20 # 報錯 can't set attribute
print(r.size)
print()

# property 實際上并不是一個函數(shù)解取，而是一個類步责。它的實例包含一些魔法方法，而所有的魔法都是由這些方法完成的
# 這些魔法方法為__get__ __set__ 和__delete__,它們一起定義了所謂的描述符協(xié)議
# 只要對象實現(xiàn)了這些方法中的任何一個禀苦，它就是一個描述符蔓肯。描述符的獨特性在于它的訪問方式
# 例如，讀取屬性（具體來說振乏，是在實例中訪問類定義的屬性）時蔗包，如果它關(guān)聯(lián)的是一個實現(xiàn)了__get__對象，
# 將不會返回這個對象慧邮，而是調(diào)用__get__方法并將結(jié)果返回


# 3.2 靜態(tài)方法和類方法
# 靜態(tài)方法：靜態(tài)方法是包轉(zhuǎn)在staticmethod類的對象中调限，靜態(tài)方法沒有參數(shù)self，可直接通過類來調(diào)用
# 類方法：類方法是包裝在classmethod類的對象中误澳，類方法包含一個類似于self的參數(shù)耻矮，通常被命名為cls。
#       對于類方法忆谓，也可通過對象來直接調(diào)用裆装，但參數(shù)cls將直接關(guān)聯(lián)到類

class MyClass:
    def smeth():
        print("this is a staticmethod")
    smeth = staticmethod(smeth)

    def cmeth(cls):
        print("this is a classmethod of",cls)
    cmeth = classmethod(cmeth)

c = MyClass()
c.smeth()
c.cmeth()
print()


class MyClass:
    @staticmethod
    def smeth():
        print("this is a staticmethod")


    @classmethod
    def cmeth(cls):
        print("this is a classmethod of",cls)


MyClass.smeth() # 方法調(diào)用 別忘了()
MyClass.cmeth() # 方法調(diào)用 別忘了()
print()



# 3.3 __getattr __setattr等方法
# 可以攔截對對象屬性的訪問企圖
# __getattribute__(self, name)：在屬性被訪問時自動調(diào)用（只適用于新式類）
# __getattr__(self, name):在屬性被訪問而對象沒有這樣的屬性時自動調(diào)用
# __setattr__(self, name, value):試圖給屬性賦值時自動調(diào)用
# __delattr__(self, name):試圖刪除屬性時自動調(diào)用

class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0
    def __setattr__(self, key, value):
        if key == 'size':
            self.width, self.height = value
        else:
            self.__dict__[key] = value

    def __getattr__(self, item):
        if item == 'size':
            return self.width, self.height
        else:
            raise AttributeError


c = Rectangle()
# print(c.name) # 報錯
c.name = 'Tana'
print(c.name) # 不報錯
print()

# ① 即便涉及的屬性不是size，也將調(diào)用__setattr__方法倡缠。因此這個方法必須考慮如下兩種情況哨免，
# 如果涉及的實行為size，就執(zhí)行和之前一樣的操作昙沦，否則琢唾，就使用魔法屬性__dict__,
# __dict__是一個字典，其中包含所有的實例屬性盾饮，之所以使用它而不是執(zhí)行常規(guī)的賦值操作采桃，
# 是為了避免再次調(diào)用__setattr__懒熙，導(dǎo)致無限循環(huán)
# ② 僅當(dāng)沒有找到指定的屬性時，才會調(diào)用方法__getattr__普办。這意味著如果指定的名稱不是size煌珊，這個方法將引發(fā)AttributeError
#  這在要讓類能夠正確的支持hasattr和getattr等內(nèi)置函數(shù)時很重要

# 在編寫方法__setattr__時要避免無限循環(huán)，編寫__getattribute__時也要這樣泌豆。由于它攔截對所有屬性的訪問（在新式類中）
# 因此將攔截對__dict__的訪問定庵。在__getattribute__中訪問當(dāng)前實例的屬性時，
# 唯一安全的方式是使用超類的方法__getattribute__(super)





###############################################################################

# 4. 迭代器
# 4.1 迭代器協(xié)議
# 迭代（iterate）意味著重復(fù)多次踪危。實現(xiàn)了方法__iter__ 的對象都可以進(jìn)行迭代
# 方法__iter__返回一個迭代器蔬浙，它是包含方法__next__的對象，而調(diào)用這個方法可不提供任何參數(shù)贞远。
# 當(dāng)你調(diào)用__next__時畴博，迭代器返回下一個值。如果迭代器沒有返回值蓝仲，應(yīng)引發(fā)StopIteration異常
# 可使用內(nèi)置的便利函數(shù)next俱病，在這種情況下，next(it)與it.__next__()等效

# 斐波那契數(shù)列
class Fibs:
    def __init__(self):
        self.a = 0
        self.b = 1
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        return self.a
    def __iter__(self):
        return self

# 找出斐波那契數(shù)列中第一大于1000的值
fibs = Fibs()
for f in fibs:
    if f>1000:
        print(f)
        break
print()

# 通過對可迭代對象調(diào)用內(nèi)置函數(shù)iter袱结，可獲得一個迭代器
it = iter([1,2,3,4])
print(next(it))
print(next(it))
print()


# 4.2 從迭代器創(chuàng)建序列
# 除了對迭代器和可迭代對象進(jìn)行迭代之外亮隙，還可以把他們轉(zhuǎn)成序列

class TestIterator:
    value =0
    def __next__(self):
        self.value +=1
        if self.value > 10:raise StopIteration
        return self.value
    def __iter__(self):
        return self

ti = TestIterator()
print(list(ti))
print()

###############################################################################

# 5. 生成器
# 5.1 創(chuàng)建生成器

def flatten(nested):
    for sublist in nested:
        for element in sublist:
            yield element

# 包含yield語句的函數(shù)都稱為生成器
# 生成器不是使用return返回一個值，而是可以生成多個值垢夹，每次一個溢吻。
# 每次使用yield生成一個值后，函數(shù)都將凍結(jié)果元，即在此停止執(zhí)行促王，等待重新喚醒，
# 重新喚醒后而晒，函數(shù)將從停止的地方開始繼續(xù)執(zhí)行

nested = [[1,2],[5,6,7]]
for num in flatten(nested):
    print(num)

print()

print(list(flatten(nested)))
print()

# 簡單生成器
# 生成器推導(dǎo)（也叫生成器表達(dá)式）其工作原理和列表推導(dǎo)相同蝇狼，
# 但不是創(chuàng)建一個列表（即不立即執(zhí)行循環(huán)），而是返回一個生成器倡怎，讓你能夠逐步計算
# 生成器推導(dǎo)迅耘，推導(dǎo)完成后，就沒有啦
g = ((i+2) ** 2 for i in range(2,27))
print(next(g))

# 計算生成器的所有值的和
from  functools import reduce
a = reduce(lambda x,y:x+y, g)
print(a)
print()

g = ((i+2) ** 2 for i in range(10,27))
print(list(g))
print()




# 5.2 遞歸式生成器
def flatten(nested):
    try:
        for sublist in nested:
            for element in flatten(sublist):
                yield element
    except TypeError:
        yield nested

print(list(flatten([[[1,2,4],[3,7],[8]],10])))

# 這個遞歸函數(shù)還有一個問題诈胜，如果nested是字符串或類似字符串的對象豹障，它就屬于序列冯事，因此不會引發(fā)TypeError
# 但在函數(shù)flatten中焦匈，不應(yīng)該對類似于字符串的對象進(jìn)行迭代，主要原因有兩個：首先昵仅，應(yīng)該把類似于字符串的對象視為原子值
# 其次缓熟，對這樣的對象迭代累魔，將會導(dǎo)致無窮遞歸，因為字符串的第一元素是長度為1的字符串够滑，
# 而長度為1的字符串的第一個元素也是字符串本身

def flatten(nested):
    try:
        # 不迭代類似于字符串的對象
        try:
            nested + ''
        except TypeError:
            pass
        else:
            raise TypeError

        for sublist in nested:
            for element in flatten(sublist):
                yield element

    except TypeError:
        yield nested

print(list(flatten(['foo',['bar',['baz']]])))
print()


# 5.3 通用生成器
# 生成器由兩個單獨部分組成：生成器的函數(shù)與生成器的迭代器
# 生成器的函數(shù)是有def語句定義的垦写，其中包含yield
# 生成器的迭代器是這個函數(shù)返回的結(jié)果。
# 用不太正確的話說彰触，這兩個實體通常被視為一個梯投，通稱為生成器

# 5.4 生成器方法
# 在生成器開始運行后，可使用生成器和外部之間的通信渠道向它提供值况毅，這個通信渠道包含兩個端點：
# ① 外部世界：外部世界可訪問生成器的方法send分蓖，這個方法類似于next，但接受一個參數(shù)（要發(fā)出的消息尔许，可以是任何對象）
# ② 生成器：在掛起的生成器內(nèi)部么鹤，yield可能用作表達(dá)式而不是語句，
# 換而言之味廊，當(dāng)生成器重新運行時蒸甜，yield返回一個值---通過send從外部世界發(fā)送的值。如果使用的是next余佛，yield將返回None
# 僅當(dāng)生成器被掛起（即遇到第一個yield）后柠新，使用send（而不是next）才有意義，
# 要在此之前向生成器提供消息辉巡，可使用生成器的函數(shù)的參數(shù)

def repeator(value):
    while True:
        new = (yield value)
        if new is not None:value =new

r = repeator(42)
print(next(r))
print(r.send('Hello Tana'))

# 生成器另外兩個方法：
# ① 方法throw：用于在生成器中（yield表達(dá)式處）引發(fā)異常登颓，調(diào)用時可提供一個異常類型 一個可選值 和一個traceback對象
# ② 方法close：用于停止生成器，調(diào)用時無需提供任何參數(shù)
# 方法close（由python垃圾收集器在需要時調(diào)用）也是基于異常的红氯，在yield處引發(fā)的GeneratorExit異常框咙。
# 因此，如果要提供一些清理代碼痢甘，可將yield放在一條try/finally語句中喇嘱。如果愿意，也可捕獲GeneratorExit異常
# 但隨后必須重新引發(fā)它（可能在清理后）塞栅、引發(fā)其他異痴咄或直接返回
# 對生成器調(diào)用close后，再試圖從它那里獲取值將導(dǎo)致RuntimeError異常


# 5.5 模擬生成器

def flatten(nested):
    result = []
    try:
        try:
            nested + ""
        except TypeError:
            pass
        else:
            raise TypeError

        for sublist in nested:
            for element in flatten(sublist):
                result.append(element)

    except TypeError:
        result.append(nested)
    return result

l = [[1,2, [3]],[5,[6]],7]
print(list(flatten(l)))
print()


###############################################################################

# 6. 八皇后問題

# 檢測沖突
# nextX表示下一個皇后的列 nextY表示下一個皇后的行
# abs(state[i]-nextX) in (0, nextY - i) 表示水平距離為0或垂直距離相等
def conflict(state, nextX):
    nextY = len(state)
    for i in range(nextY):
        if abs(state[i]-nextX) in (0, nextY - i):
            return True
    return False

def queens(num=8, state=()):
    for pos in range(num):
        if not conflict(state, pos):
            if len(state) == num-1:
                yield (pos,)

            else:
                for result in queens(num, state+(pos,)):
                    yield (pos,) +result


print(list(queens(8)))