Mac操作體系下MySQL暗碼忘卻後重置暗碼的辦法。本站提示廣大學習愛好者：（Mac操作體系下MySQL暗碼忘卻後重置暗碼的辦法）文章只能為提供參考，不一定能成為您想要的結果。以下是Mac操作體系下MySQL暗碼忘卻後重置暗碼的辦法正文
太棒了，如今用一個實例作為它的的第一個參數來挪用，全部世界都僻靜了，假如我說這類挪用方法還不是最便利的，你也會這麼以為的；沒錯，如今每次挪用這個辦法的時刻我們都不能不援用這個類，假如不曉得哪一個類是我們的對象，歷久看來這類方法是行欠亨的。
那末Python為我們做了甚麼呢，它綁定了一切來自類_Pizza的辦法和該類的任何一個實例的辦法。也就意味著如今屬性get_size是Pizza的一個實例對象的綁定辦法，這個辦法的第一個參數就是該實例自己。
>>> Pizza(42).get_size <bound method Pizza.get_size of <__main__.Pizza object at 0x7f3138827910>> >>> Pizza(42).get_size() 42
和我們預期的一樣，如今不再須要供給任何參數給_get_size，由於它曾經是綁定的，它的self參數會主動地設置給Pizza實例，上面代碼是最好的證實：
>>> m = Pizza(42).get_size >>> m() 42
更有甚者，你都沒需要應用持有Pizza對象的援用了，由於該辦法曾經綁定到了這個對象，所以這個辦法對它本身來講是曾經足夠了。
或許，假如你想曉得這個綁定的辦法是綁定在哪一個對象上，上面這類手腕就可以得知：
>>> m = Pizza(42).get_size >>> m.__self__ <__main__.Pizza object at 0x7f3138827910> >>> # You could guess, look at this: ... >>> m == m.__self__.get_size True
明顯，該對象依然有一個援用存在，只需你情願你照樣可以把它找回來。
在Python3中，依靠在類上的函數不再看成是未綁定的辦法，而是把它看成一個簡略地函數，假如有需要它會綁定到一個對象身上去，准繩仍然和Python2堅持分歧，然則模塊更簡練：
>>> class Pizza(object): ... def __init__(self, size): ... self.size = size ... def get_size(self): ... return self.size ... >>> Pizza.get_size <function Pizza.get_size at 0x7f307f984dd0>
靜態辦法
靜態辦法是一類特別的辦法，有時你能夠須要寫一個屬於這個類的辦法，然則這些代碼完整不會應用到實例對象自己，例如：
class Pizza(object):
@staticmethod
def mix_ingredients(x, y):
return x + y
def cook(self):
return self.mix_ingredients(self.cheese, self.vegetables)
這個例子中，假如把_mix_ingredients作為非靜態辦法異樣可以運轉，然則它要供給self參數，而這個參數在辦法中基本不會被應用到。這裡的@staticmethod裝潢器可以給我們帶來一些利益：
Python不再須要為Pizza對象實例初始化一個綁定辦法，綁定辦法異樣是對象，然則創立他們須要本錢，而靜態辦法便可以免這些。
>>> Pizza().cook is Pizza().cook False >>> Pizza().mix_ingredients is Pizza.mix_ingredients True >>> Pizza().mix_ingredients is Pizza().mix_ingredients True
可讀性更好的代碼，看到@staticmethod我們就曉得這個辦法其實不須要依附對象自己的狀況。
可以在子類中被籠罩，假如是把mix_ingredients作為模塊的頂層函數，那末繼續自Pizza的子類就沒法轉變pizza的mix_ingredients了假如不籠罩cook的話。
類辦法
話雖如斯，甚麼是類辦法呢？類辦法不是綁定到對象上，而是綁定在類上的辦法。
>>> class Pizza(object): ... radius = 42 ... @classmethod ... def get_radius(cls): ... return cls.radius ... >>> >>> Pizza.get_radius <bound method type.get_radius of <class '__main__.Pizza'>> >>> Pizza().get_radius <bound method type.get_radius of <class '__main__.Pizza'>> >>> Pizza.get_radius is Pizza().get_radius True >>> Pizza.get_radius() 42
不管你用哪一種方法拜訪這個辦法，它老是綁定到了這個類身上，它的第一個參數是這個類自己（記住：類也是對象）。
甚麼時刻應用這類辦法呢？類辦法平日在以下兩種場景長短常有效的：
工場辦法：它用於創立類的實例，例如一些預處置。假如應用@staticmethod取代，那我們不能不硬編碼Pizza類名在函數中，這使得任何繼續Pizza的類都不克不及應用我們這個工場辦法給它本身用。
class Pizza(object):
def __init__(self, ingredients):
self.ingredients = ingredients
@classmethod
def from_fridge(cls, fridge):
return cls(fridge.get_cheese() + fridge.get_vegetables())
挪用靜態類：假如你把一個靜態辦法拆分紅多個靜態辦法，除非你應用類辦法，不然你照樣得硬編碼類名。應用這類方法聲明辦法，Pizza類名明永久都不會在被直接援用，繼續和辦法籠罩都可以完善的任務。
class Pizza(object):
def __init__(self, radius, height):
self.radius = radius
self.height = height
@staticmethod
def compute_area(radius):
return math.pi * (radius ** 2)
@classmethod
def compute_volume(cls, height, radius):
return height * cls.compute_area(radius)
def get_volume(self):
return self.compute_volume(self.height, self.radius)
籠統辦法
籠統辦法是界說在基類中的一種辦法，它沒有供給任何完成，相似於Java中接口(Interface)外面的辦法。
在Python中完成籠統辦法最簡略處所式是：
class Pizza(object):
def get_radius(self):
raise NotImplementedError
任何繼續自_Pizza的類必需籠罩完成辦法get_radius，不然會拋出異常。
這類籠統辦法的完成有它的弊病，假如你寫一個類繼續Pizza，然則忘卻完成get_radius，異常只要在你真正應用的時刻才會拋出來。
>>> Pizza() <__main__.Pizza object at 0x7fb747353d90> >>> Pizza().get_radius() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 3, in get_radius NotImplementedError
還有一種方法可讓毛病更早的觸發，應用Python供給的abc模塊，對象被初始化以後便可以拋出異常：
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_radius(self):
"""Method that should do something."""
應用abc後，當你測驗考試初始化BasePizza或許任何子類的時刻立馬就會獲得一個TypeError，而無需比及真正挪用get_radius的時刻才發明異常。
>>> BasePizza() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius
混雜靜態辦法、類辦法、籠統辦法
當你開端構建類和繼續構造時，混雜應用這些裝潢器的時刻到了，所以這裡列出了一些技能。
記住，聲明一個籠統的辦法，不會固定辦法的原型，這就意味著固然你必需完成它，然則我可以用任何參數列表來完成：
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""
class Calzone(BasePizza):
def get_ingredients(self, with_egg=False):
egg = Egg() if with_egg else None
return self.ingredients + egg
如許是許可的，由於Calzone知足BasePizza對象所界說的接口需求。異樣我們也能夠用一個類辦法或靜態辦法來完成：
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""
class DietPizza(BasePizza):
@staticmethod
def get_ingredients():
return None
這異樣是准確的,由於它遵守籠統類BasePizza設定的契約。現實上get_ingredients辦法其實不須要曉得前往成果是甚麼，成果是完成細節，不是契約前提。
是以，你不克不及強迫籠統辦法的完成是一個慣例辦法、或許是類辦法照樣靜態辦法，也沒甚麼可爭辯的。從Python3開端（在Python2中不克不及如你等待的運轉，見issue5867），在abstractmethod辦法下面應用@staticmethod和@classmethod裝潢器成為能夠。
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
ingredient = ['cheese']
@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.ingredients
別誤解了，假如你以為它會強迫子類作為一個類辦法來完成get_ingredients那你就錯了，它僅僅表現你完成的get_ingredients在BasePizza中是一個類辦法。
可以在籠統辦法中做代碼的完成？沒錯，Python與Java接口中的辦法相反，你可以在籠統辦法編寫完成代碼經由過程super()來挪用它。（譯注：在Java8中，接口也供給的默許辦法，許可在接口中寫辦法的完成）
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
default_ingredients = ['cheese']
@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.default_ingredients
class DietPizza(BasePizza):
def get_ingredients(self):
return ['egg'] + super(DietPizza, self).get_ingredients()
這個例子中，你構建的每一個pizza都經由過程繼續BasePizza的方法，你不能不籠罩get_ingredients辦法，然則可以或許應用默許機制經由過程super()來獲得ingredient列表。
