1、類的結構
1.使用面向對象開發，第一步是設計類
2.使用 類名() 創建對象，創建對象的動作有兩步
?? ?1.在內存中為對象分配空間
?? ?2.調用初始化方法__init___ 為對象初始化
3.對象創建后，內存中就有了一個對象的實實在在的存在--實例

因此：
1.創建出來的對象叫做類的實例
2.創建對象的動作叫做實例化
3.對象的屬性叫做實例屬性
4.對象調用的方法叫做實例方法

在程序執行時：
1.對象各自擁有自己的實例屬性
2.調用對象的方法，可以通過self
?? ?訪問自己的屬性
?? ?調用自己的方法
結論:
1.每一個對象都有自己獨立的內存空間，保存各自不同的屬性
2.多個對象的方法，在內存中之有一份，在調用方法時，需要把對象的引用傳遞到方法內部

?

2、類屬性
Python: 一切皆對象
類是一個特殊的對象---類對象
在程序運行的時候，類對象(創建實例對象的模板)在內存中只有
一份，通過它可以創建出和很多個對象實例
除了封裝實例的屬性和方法外，類對象還可以擁有自己的屬性和方法
1.類屬性
2.類方法

通過 類名. 的方式可以直接訪問類的屬性

類屬性：就是給類對象定義的屬性
?????? 通常用來記錄與這個類相關的特征
?????? 類屬性不會用于記錄具以的對象特征
定義一個工具類，每個工具都有自己的名字
需要知道使用這個類，創建了多少個工具對象

例：

class Tool(object):# 1.使用賦值語句定義類屬性，記錄所有工具的數量count = 0def __init__(self, name):self.name = name# 讓類屬性+1Tool.count += 1
# 創建工具對象
tool1 = Tool('斧頭')
tool2 = Tool('榔頭')# 輸出工具對象的總數
# 使用類名.屬性名來獲取
print Tool.count

3.類方法：

類屬性就是針對類對象定義的使用賦值語句在class關鍵字下可以定義類屬性類屬性用于記錄于這個類相關的特性
類方法就是針對類對象定義的方法在類方法內部就可以直接訪問類屬性或者調用其他類方法
例：
class Toy(object):# 使用賦值語句定義類屬性，記錄所有玩具的數量count = 0@classmethoddef show_toy_count(cls):# cls.count 在類方法內部，訪問當前的類屬性print '玩具對象的數量 %d' % cls.countdef __init__(self, name):self.name = name# 讓類屬性+1Toy.count += 1#創建玩具對象
toy1 = Toy('樂高')
toy2 = Toy('玩具熊')#調用類方法
Toy.show_toy_count()

4.靜態方法在開發的時候，如果需要在類中封裝一個方法，這個方法即不需要訪問實例屬性或者調用實例方法也不需要訪問類屬性或者調用類方法這個時候，我們就可以把這個方法封裝成一個靜態方法
例：
class Cat(object):# 不訪問實例屬性/類屬性@staticmethoddef call():print '喵喵～'
# 通過 類名. 調用靜態方法
Cat.call()
# 不需要創建對象，直接就可以使用

總結:
1.實例方法--方法內部需要訪問實例屬性
?? ?實例方法內部可以使用 類名. 訪問類屬性
2.類方法：方法內部“只”需要訪問類屬性
3.靜態方法：方法內部，不需要訪問實例屬性和類屬性

提問：
如果方法內部 即需要訪問實例屬性，又需要訪問類屬性，應該定義什么方法?
答案：
應該定義實例方法,因為類只有一個，在實例方法內部可以使用類名，訪問類屬性

?

單例：設計模式：

??????? 設計模式是前人的總結和經驗的提煉，通常，被人人們廣為流傳的設計模式都是針對某一特定問題的成熟解決方案

單例設計模式

單例：讓類創建的對象，在系統中有唯一的實例

創建對象的時候：

1.為對象分配空間:__new__()

創建對象的時候，python解釋器首先會調用__new__方法為ie對象分配空間

__new__是一個由object基類提供的內置的靜態方法，主要有兩個作用：

??????? 在內存中為對象分配空間

??????? 返回對象的引用

2.對象初始化 ：__init__()

python解釋器獲得對象的引用后，將引用的第一個參數，傳遞給__init__方法

例：

class MusicPlyer(object):def __new__(cls, *args, **kwargs):# 第一個參數cls：哪一個類調用就傳遞哪一個類# 第二個參數*args:是一個多值元組參數# 第三個參數**kwargs:是一個多值的字典參數# 1.創建對象時，new方法會被自動調用print '創建對象，分配空間' # 重寫了父類的方法#2.為對象分配空間# __new__方法是一個靜態方法，在調用的時候，第一個參數是clsinstance = object.__new__(cls)# 3.返回對象的引用return instancedef __init__(self):print '初始化播放器'
# 創建播放器對象
player1 = MusicPlyer()
print player1
player2  =MusicPlyer()
print player2

總結：

??? 重寫__new__方法的代碼非常固定：
?? ?繼承自父類方法
?? ?返回父類方法調用_new__方法的結果
重寫__new__方法一定要return object.__new__(cls)
否則python的解釋器得不到分配了空間的對象引用，就不會調用對象的初始化方法

"""
"""
python中的單例：
單例：讓類創建的對象，在系統中只有唯一的一個實例
??????? 1.定義一個類屬性，初始值時None,用于記錄單例對象的引用(因為當一個類定義完成運行程序的時候，
??????? 內存中有這個類創建的對象么？
并沒有，我們需要調用創建對象的方法，內存中才會有第一個對象)
??????? 2.重寫__new__方法
??????? 3.如果類屬性is None,調用父類方法分配空間，并在類屬性中記錄結果
??????? 4.返回類屬性中記錄的對象引用

程序執行時，只執行一次初始化工作
在每次使用 類名() 創建對象時，python的解釋器都會自動調用兩個方法
?? ?__new__ 分配空間
?? ?__init__ 對象初始化
但在上一小結中 __new__方法改造之后，每次都會得到第一次被創建對象的引用
但是：初始化方法還會被再次掉用

需求：讓初始化方法只執行一次
解決辦法：
1.定義一個類屬性init_flag標記是否執行過初始化動作，初始值為false
2.在__init__方法中，判斷init_flag，如果為false就執行初始化動作
3.然后將init_flag設置為trun
4.這樣，再次自動調用__init__方法時，初始化動作就不會再次被執行了

例：

class MusicPlayer(object):# 記錄第一個被創建對象的應用instance = Noneinit_flag = Falsedef __new__(cls, *args, **kwargs):# 判斷類屬性是否為空(如果是空對象，說明第一個對象還沒被創建)if cls.instance is None:# 調用父類的方法，為第一個對象分配空間cls.instance = object.__new__(cls)# 返回類屬性保存的對象引用return cls.instancedef __init__(self):# 1.判斷是否執行過初始化方法if MusicPlayer.init_flag:return# 2.如果沒有執行，執行初始化動作print '初始化播放器'# 3.修改類屬性的標記MusicPlayer.init_flag = True# 創建多個對象
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2

1、異常:

什么是異常？
程序在運行的時候，如果python解釋器遇到一個錯誤，會停止程序的執行，
并且提示一些錯誤的信息，這就是異常

怎樣避免這種情況的發生？
我們在程序開發的時候，很難將所有的特殊情況都處理，通過異常捕獲可以針對
突發事件做集中處理，從而保證程序的健壯性和穩定性

需要執行的步驟是什么？

在程序開發中，如果對某些代碼的執行不能確定(程序語法完全正確)
可以增加try來捕獲異常
try:
??? 嘗試執行的代碼
except:
??? 出現錯誤的處理

例如：

正常情況下：

num = int(raw_input('請輸入一個整數:'))print '請輸入正確的整數'print '*' * 50

增加try后捕獲異常

try:# 不能確定正確執行的代碼num = int(raw_input('請輸入一個整數:'))
except:print '請輸入正確的整數'print '*' * 50

2、根據錯誤類型捕獲異常

需求：
??? 1.提示用戶輸入一個整數
??? 2.使用8除以用戶輸入的整數并輸出
根據錯誤類型來捕獲異常
try:
??? 嘗試執行的代碼
except 錯誤類型1：
??? 針對錯誤類型1，對應的代碼處理
except 錯誤類型2：
??? 針對錯誤類型2，對應的代碼處理

try:# 提示用戶輸入一個整數num = int(raw_input('輸入一個整數:'))# 使用8除以整數并且輸出result = 8 / numprint result
except ZeroDivisionError:print '0不能做除數'
except ValueError:print '輸入的值不是數字'
"""
1.0不能做除數
2.輸入的值不是數字
"""
print '* ' * 50

3、根據報錯來寫try:

try:num = int(raw_input('輸入一個整數:'))# 使用8除以整數并且輸出result = 8 / numprint result
except ZeroDivisionError:print '0不能做除數'
except ValueError:print '輸入的值不是數字'
# 沒有預先判斷到的錯誤，但是如果出現，我們也不希望程序意外停止
finally:# 無論是否有異常，都會執行的代碼print '祝您使用愉快'

4、沒有預先判斷到的錯誤，但是如果出現，我們也不希望程序意外停止
try:
??? # 提示用戶輸入一個整數
??? num = int(raw_input('輸入一個整數:'))

??? # 使用8除以整數并且輸出
??? result = 8 / num
??? print result
except ZeroDivisionError:
??? print '0不能做除數'
except Exception as result:
??? print '未知錯誤 %s' % result
finally:
??? # 無論是否有異常，都會執行的代碼
??? print '祝您適用愉快!!'

異常的傳遞：

def demo1():return int(raw_input('輸入整數:'))def demo2():return demo1()print demo2()

通過查看報錯信息，可以知道

函數的錯誤是一級一級的去找，最終會將異常傳遞到主程序print demo2()里面

解決問題：

保證程序的正常運行

def demo1():return int(raw_input('輸入整數:'))def demo2():return demo1()

try:print demo2()
except Exception as result:print '未知錯誤 %s' % result
print '*'*20

5、主動拋出異常

需求 ：

??????? 提示用戶輸入密碼，如果長度小于8，就拋出異常

def input_passwd():# 1.提示用戶輸入密碼pwd = raw_input('請輸入密碼：')# 2.判斷密碼的長度 >=8,返回用戶的密碼if len(pwd) >= 8:return pwd# 3.如果<8 主動拋出異常print '主動拋出異常'# 1.創建異常對象ex = Exception('密碼長度不夠')# 2.主動拋出異常raise ex
# 注意：只拋出異常而不捕獲異常，代碼會出錯
try:print input_passwd()
except Exception as result:print result

6、斷言

??????? 可以理解為提前預言，讓人更好的知道錯誤的原因

def func(num, div):assert (div != 0), 'div不能為0'return num / divprint func(10, 0)

?