python學習之路基礎篇(第八篇)

一、作業（對象的封裝）        　　
　　要點分析
            1.封裝，對象中嵌套對象
            2.pickle,load,切記，一定要先導入相關的類
二、上節內容回顧和補充    　　　　
   面向對象基本知識：
        1.類和對象的關系
        2.三大特性：
            封裝
            繼承
    面向對象的三大特性：多態的補充
            多態（多種形態，多種類型）
python的多態

def func(arg):print(arg)func(1)
func('lili')
func([11,22,33])

JAVA/C++的多態

#用python語言的格式來寫JAVA/C++語言的多態
def func(int arg):print(arg)func(123)
func('hangzheng')  #此種寫法在java和c++會報錯，原因在于，上面已經明確定義arg的類型是int#JAVA/C++語言中多態的表現形式
class A:pass
class B(A):pass
class C(A):pass#arg參數：必須要是A類型或A的子類型
def func(A arg):print(arg)#obj = B()
#obj = C()
obj = A()
func(obj)

三、面向對象 類成員

    1.字段  
        普通字段  屬于對象，由對象來進行調用

#普通字段
class  Province:def __init__(self,name):self.name = nameself.country = "中國"def show(self):print(self.name)hlj = Province("黑龍江")
sd = Province('山東')
print(hlj.name)
print(sd.name)
#其中：name country都是普通字段
#此程序的缺點：每次打印的時候都會打印出“中國”，在內存中就會保存多份相同的country字段"中國"

疑問：在保證省份正常輸出的情況下，能不能使其就保存一份呢？解決此問題的方法：靜態字段

 靜態字段　屬于類，由類來進行調用

?

#靜態字段在內存中只保存一份，普通方法則需要在內存中保存多份
class Province:#靜態字段，保存在類中country = "中國"def __init__(self,name):#動態字段，保存在對象中self.name = namehn = Province("河南")
hb = Province("河北")
#一般情況下，自己訪問自己的字段
#規則：普通字段只能用對象訪問
#靜態字段用類訪問（萬不得已的時候可以使用對象訪問）
print(hn.name)
print(Province.country)
print(hb.country)#說明
#country保存在類中，內存中有country
#類一旦被加載，靜態字段就有值
#靜態字段在代碼加載時，已經創建

       
    2.方法
        所有的方法屬于類
        1.普通方法：至少一個self,由對象調用執行
        2.靜態方法：任意參數，  由類調用執行（對象執行）
        3.類方法：  至少一個cls, 由類調用執行（對象執行）

#普通方法  靜態方法  類方法
class Province:#靜態字段，屬于類，由類進行調用country = "中國"def __init__(self,name):#普通字段，屬于對象，由對象調用self.name = name#普通方法：由對象調用執行（方法屬于類）def show(self):print(123)@staticmethoddef f1(cla,arg1,arg2):#靜態方法，由類來進行調用，不需要創建對象即可進行調用#參數可無，也可以是多個#當方法內部不需要對象中封裝的值時，可以將方法寫成靜態方法print(arg1,arg2)

　　

    3.屬性
        不倫不類的東西
            具有方法的寫作形式，具有字段的訪問形式

#屬性：讓方法以字段的方式去訪問
class Pager:def __init__(self,all_count):self.all_count = all_count@propertydef all_pager(self):a1,a2 = divmod(self.all_count,10)if a2 == 0:return a1else:return a1 + 1@all_pager.setterdef all_pager(self,value):print(value)@all_pager.deleterdef all_pager(self):print('del all_pager')p = Pager(101)
#p.all_count  #字段
#result = p.all_pager()   #方法
#print(result)#屬性相關操作
#以字段方式去調用方法
ret = p.all_pager  #調用方法即執行@property
print(ret)
p.all_pager = 123   #給字段重新賦值,執行此操作時即執行@all_pager.setter方法
ret = p.all_pager
print(ret)
del p.all_pager   #刪除字段,執行此操作時即執行@all_pager.deleter方法

屬性的第二種表現形式：

class Pager:def __init__(self,all_count):self.all_count = all_countdef f1(self):return 123def f2(self,value):passdef f3(self):passfoo = property(fget=f1,fset=f2,fdel=f3)p = Pager(101)
result = p.foo
print(result)p.foo = 'alex'del p.foo

說明：當執行p.foo時，會執行fget=f1,也即會執行第一個函數f1,

? ? ? ? 當執行p.foo='alex'時,會執行fget=f2,也即會執行第二個函數f2

　　 ?當執行del p.foo時，會執行fget=f3,也即會執行第三個函數f3

四、成員修飾符
成員：字段  方法  屬性
共有：內外部都可以進行訪問
私有：只能類自己本身成員內部可以訪問
注意：不到萬不得已不要在外部強制訪問私有成員  對象._類名__name

class Foo:# 靜態字段__cc = "123"def __init__(self, name):# 普通字段，私有成員self.__name = namedef f1(self):print(self.__name)@staticmethoddef f3():print(Foo.__cc)print(Foo.__cc)
#obj = Foo('hello')
#print(obj.__name)
#obj.f1()
# obj.f3()
#Foo.f3()

執行結果如下：

C:\python35\python3.exe D:/PythonS13/Day8/homework/blog.py
Traceback (most recent call last):File "D:/PythonS13/Day8/homework/blog.py", line 20, in <module>print(Foo.__cc)
AttributeError: type object 'Foo' has no attribute '__cc'

說明：報錯信息中提示：AttributeError: type object 'Foo' has no attribute '__cc'，而實際上__cc是存在的，那為什么還會報錯呢？大家注意看靜態字段cc前面多了兩個下劃線(__)，由于字段前面有了兩個下劃線，此時靜態字段已經變為了靜態私有字段，既然是私有的，在外部當然不可以別調用了。所以在外部調用私有字段時就會報錯。

#普通方法
class Foo:#靜態字段__cc = "123"def __init__(self,name):#私有字段self.name = namedef __f1(self):print(self.name)def f2(self):passdef f3(self):self.__f1()@staticmethoddef f4():print(Foo.__cc)#print(Foo.__cc)  報錯
obj = Foo('hello')
obj.f3()
Foo.f4()obj = Foo('alex')
#obj.__f1()  報錯

#靜態方法
class Foo:#靜態字段__cc = "123"def __init__(self,name):#私有字段self.name = namedef f1(self):print(self.name)@staticmethoddef __f2():print(Foo.__cc)@staticmethoddef f3():Foo.__f2()obj = Foo('alex')
obj.f1()
#Foo.__f2()  #調用私有靜態方法會報錯
Foo.f3()

#類方法
class Foo:#靜態字段__cc = "123"def __init__(self,name):#私有字段self.name = namedef f1(self):print(self.name)@staticmethoddef __f2():print(Foo.__cc)@staticmethoddef f3():Foo.__f2()@classmethoddef f4(cls):Foo.__f5()@classmethoddef __f5(cls):print(cls)#Foo.__f5()  調用私有類方法會報錯
Foo.f4()

五、特殊成員
1.__init__
　__init__：構造函數，通過類創建對象時，自動觸發執行

class Foo:def __init__(self, name):self.name = nameself.age = 18obj = Foo('mohan') # 自動執行類中的 __init__ 方法

2.__module__和__class__
__module__：表示當前操作的對象在哪個模塊
__class__：表示當前操作的對象的類是什么

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#__module__和__class__#lib/demo
class C:def __init__(self):self.name = 'zhangsan'#index.py
from lib.demo import Cobj = C()
print(obj.__module__) # 輸出 lib.aa，即：輸出模塊
print(obj.__class__)      # 輸出 lib.aa.C，即：輸出類#程序執行結果
lib.demo
<class 'lib.demo.C'>　

4.__del__
__del__:析構方法，當對象在內存中被釋放時，自動觸發執行
注：此方法一般無需定義，因為python是一門高級語言，程序員在使用時無需關心內存的分配和釋放，因為此工作都是交給python解釋器來執行，所以，析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的

class Foo:def __del__(self):print("我馬上要消失了")

5.__call__
對象后面加括號，觸發執行
注：構造方法的執行是由創建對象觸發的，即：對象 = 類名();而對于__call__方法的執行是由對象后面加括號觸發的，即：對象()或者是類()

class Foo:def __init__(self):passdef __call__(self, *args, **kwargs):print '__call__'obj = Foo() # 執行 __init__
obj()       # 執行 __call__

6.__doc__:類的描述信息

class Foo:""" 描述類信息，定義一個函數 """def func(self):passprint(Foo.__doc__)
#輸出：類的描述信息

7.__dict__
類或對象中的所有成員
普通字段屬于對象，類中的靜態字段和方法屬于類

class Province:country = '中國'def __init__(self, name, count):self.name = nameself.count = countdef func(self, *args, **kwargs):print 'func'# 獲取類的成員，即：靜態字段、方法、
print(Province.__dict__)
# 輸出：{'country': '中國', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}obj1 = Province('河南',100000)
print(obj1.__dict__)
# 獲取 對象obj1 的成員
# 輸出：{'count': 100000, 'name': '河南'}obj2 = Province('山東', 4888)
print(obj2.__dict__)
# 獲取 對象obj1 的成員
# 輸出：{'count': 4888, 'name': '山東'}

7.__str__

如果一個類中定了__str__方法，那么在打印對象是，默認輸出該方法的返回值

class Foo:def __str__(self):return 'mohan'obj = Foo()
print(obj)
# 輸出：mohan

8.__getitem__ 、__setitem__、__delitem__

用于索引操作，如字典。以上分別表示獲取、設置、刪除數據

#!/usr/bin/env python

class Foo(object):def __getitem__(self, key):print( '__getitem__',key)def __setitem__(self, key, value):print('__setitem__',key,value)def __delitem__(self, key):print( '__delitem__',key)obj = Foo()result = obj['k1']      # 自動觸發執行 __getitem__
obj['k2'] = 'mohan'   # 自動觸發執行 __setitem__
del obj['k1']           # 自動觸發執行 __delitem__

9.__getslice__、__setslice__、__delslice__

　這三個方法用于分片操作，如：列表

#!/usr/bin/env pythonclass Foo(object):def __getslice__(self, i, j):print( '__getslice__',i,j)def __setslice__(self, i, j, sequence):print( '__setslice__',i,j)def __delslice__(self, i, j):print( '__delslice__',i,j)obj = Foo()obj[-1:1]                   # 自動觸發執行 __getslice__
obj[0:1] = [11,22,33,44]    # 自動觸發執行 __setslice__
del obj[0:2]                # 自動觸發執行 __delslice__

10.__iter__

用于迭代器，之所以列表、字典、元組可以進行for循環，是因為類型內部定義了__iter__

class Foo(object):passobj = Foo()for i in obj:print(i)# 報錯：TypeError: 'Foo' object is not iterable

class Foo(object):def __iter__(self):passobj = Foo()for i in obj:print(i)# 報錯：TypeError: iter() returned non-iterator of type 'NoneType'

#!/usr/bin/env python
# -*- coding:utf-8 -*-class Foo(object):def __init__(self, sq):self.sq = sqdef __iter__(self):return iter(self.sq)obj = Foo([11,22,33,44])for i in obj:print(i)

從以上步驟可以看出 ，for循環迭代的其實是iter([11,22,3,44])，所以執行流程可以變更為：

obj = iter([11,22,33,44])
for i in obj:print(i)

for循環內部語法結構;

obj = iter([11,22,33,44])while True:val = obj.next()print(val)

10.__new__和__metaclass__

請閱讀以下代碼：

class Foo(object):def __init__(self):passobj = Foo()   # obj是通過Foo類實例化的對象

上述代碼中，obj是通過FOO類實例化的對象，其實，不僅obj是一個對象，FOO類本身也是一個對象，因為python中一切事物都是對象。

如果按照一切都是對象的理論：obj對象是通過FOO類的構造方法創建，那么FOO類對象應該也是通過執行某個類的構造方法創建的。

print(type(obj)) # 輸出：<class '__main__.Foo'>     表示，obj 對象由Foo類創建
print(type(Foo)) # 輸出：<type 'type'>              表示，Foo類對象由 type 類創建

所以，obj對象是Foo類的一個實例，Foo類對象是 type 類的一個實例，即：Foo類對象 是通過type類的構造方法創建。

創建類的兩種方式：

1.普通方式

class Foo(object):def func(self):print('hello mohan')　　

2.特殊方式（type類的構造函數）

def func(self):print('hello mohan')Foo = type('Foo',(object,), {'func': func})
#type第一個參數：類名
#type第二個參數：當前類的基類
#type第三個參數：類的成員

類默認是由type類實例化產生，type類中如何實現的創建類，類又是如何創建對象？

答：類中有一個屬性__metaclass__，其用來表示類是由誰來實例化創建，所以，我們可以為__metaclass__設置一個type類的派生類，從而查看類創建的過程。

class MyType(type):def __init__(self, what, bases=None, dict=None):super(MyType, self).__init__(what, bases, dict)def __call__(self, *args, **kwargs):obj = self.__new__(self, *args, **kwargs)self.__init__(obj)class Foo(object):__metaclass__ = MyTypedef __init__(self, name):self.name = namedef __new__(cls, *args, **kwargs):return object.__new__(cls, *args, **kwargs)# 第一階段：解釋器從上到下執行代碼創建Foo類
# 第二階段：通過Foo類創建obj對象
obj = Foo()

其他相關　　

一、isinstance(obj,cls)

檢查obj是否是類cls的對象

class Foo(object):passobj = Foo()isinstance(obj, Foo)

二、issubclass(sub,super)

檢查sub類是否是super類的派生類

class Foo(object):passclass Bar(Foo):passissubclass(Bar, Foo)

六、設計模式之單例模式
七、面向對象其他
　　-isinstance
　　_issubclass
　　_應用：
　　　　1.自定義類型，對字典進行補充，有序字典
　　　　2.對源碼的擴展

八、異常處理
1、異常基礎
在編程過程中為了增加友好性，在程序出現bug時一般不會將錯誤信息顯示給用戶，而是顯示一個事先定義好的提示的頁面，通俗來說就是不讓用戶看見大黃頁！！！

try:pass
except Exception,ex:pass　　

需求：求和

while True:num1 = input('num1:')num2 = input('num2:')try:num1 = int(num1)num2 = int(num2)result = num1 + num2except Exception, e:print '出現異常，信息如下：'print e

2、異常種類

python中的異常種類非常多，每個異常專門處理 某一項異常。

常見異常:

AttributeError 試圖訪問一個對象沒有的樹形，比如foo.x，但是foo沒有屬性x
IOError 輸入/輸出異常；基本上是無法打開文件
ImportError 無法引入模塊或包；基本上是路徑問題或名稱錯誤
IndentationError 語法錯誤（的子類） ；代碼沒有正確對齊
IndexError 下標索引超出序列邊界，比如當x只有三個元素，卻試圖訪問x[5]
KeyError 試圖訪問字典里不存在的鍵
KeyboardInterrupt Ctrl+C被按下
NameError 使用一個還未被賦予對象的變量
SyntaxError Python代碼非法，代碼不能編譯(個人認為這是語法錯誤，寫錯了）
TypeError 傳入對象類型與要求的不符合
UnboundLocalError 試圖訪問一個還未被設置的局部變量，基本上是由于另有一個同名的全局變量，
導致你以為正在訪問它
ValueError 傳入一個調用者不期望的值，即使值的類型是正確的

更多異常

ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

實例

#IndexErrordic = ["mohan", 'yamei']
try:dic[10]
except IndexError, e:print(e)#KeyError
dic = {'k1':'v1'}
try:dic['k20']
except KeyError, e:print(e)#ValueError
s1 = 'hello'
try:int(s1)
except ValueError, e:print(e)

對于上述實例，異常類只能處理指定的異常情況，如果非指定異常則無法處理

# 未捕獲到異常，程序直接報錯s1 = 'hello'
try:int(s1)
except IndexError,e:print(e)

所以，寫程序時需要考慮到try代碼塊中可能出現的任意異常，可以這樣寫：

s1 = 'hello'
try:int(s1)
except IndexError,e:print(e)
except KeyError,e:print(e)
except ValueError,e:print(e)

萬能異常：在python的異常中，Exception，它可以捕獲任意異常

s1 = 'hello'
try:int(s1)
except Exception,e:print(e)

既然這樣，python中的其他異常是不是就可以忽略了？

當然不是，對于特殊處理或提醒的異常需要先定義，最后定義Exception來確保程序的執行

s1 = 'hello'
try:int(s1)
except KeyError,e:print('鍵錯誤')
except IndexError,e:print('索引錯誤')
except Exception, e:print('錯誤')

3、異常其他結構

try:# 主代碼塊pass
except KeyError,e:# 異常時，執行該塊pass
else:# 主代碼塊執行完，執行該塊pass
finally:# 無論異常與否，最終執行該塊pass

4、主動觸發異常?

try:raise Exception('錯誤了。。。')
except Exception,e:print(e)

5、自定義異常

class MohanException(Exception):def __init__(self, msg):self.message = msgdef __str__(self):return self.messagetry:raise  MohanException('我的異常')
except  MohanException,e:print(e)

　　

?

　　

?

　

?

?

參考：http://www.cnblogs.com/wupeiqi/articles/5017742.html
　　　http://www.cnblogs.com/wupeiqi/p/4766801.html