WEEK7：面向對象編程進階

時間 2019-12-10

原文原文鏈接

面向對象高級語法部分

靜態方法、類方法、屬性方法

靜態方法 @staticmethod #此方法實際上跟類已經沒什麼關係了，此時就是單純的函數，沒法直接調用類變量，可是能夠經過傳進去實例調用類變量。靜態方法只是名義上歸類管理，實際上在靜態方法裏訪問不了類或者實例中的任何屬性

 1 import os
 2 
 3 class Dog(object):
 4     def __init__(self,name):
 5         self.name = name
 6 
 7     @staticmethod #此方法實際上跟類已經沒什麼關係了，此時就是單純的函數，沒法直接調用類變量和實例變量，可是能夠經過傳進去實例調用實例變量
 8     def eat(self):
 9         print("%s is eating %s" %(self.name,'dd'))
10 
11     def talk(self):
12         print("%s is talking"% self.name)
13 d = Dog("ChenRonghua")
14 d.eat(d)
15 d.talk()

類方法 @classmethod #只能訪問類變量，不能訪問實例變量

 1 import os
 2 
 3 class Dog(object):
 4     name = "huazai"
 5     def __init__(self,name):
 6         self.name = name
 7     @classmethod #只能訪問類變量，不能訪問實例變量
 8     def eat(self):
 9         print("%s is eating %s" %(self.name,'dd'))
10 
11     def talk(self):
12         print("%s is talking"% self.name)
13 
14 
15 d = Dog("ChenRonghua")
16 d.eat()

屬性方法 @property #把一個方法變成靜態屬性，調用的時候不須要加（），沒法傳遞參數

 1 import os
 2 
 3 class Dog(object):
 4     '''這個類是描述狗這個對象的'''
 5 
 6     def __init__(self,name):
 7         self.name = name
 8         self.__food = None
 9 
10     @property #把一個方法變成靜態屬性，調用的時候不須要加（）
11     def eat(self):
12         print("%s is eating %s" %(self.name,self.__food))
13     @eat.setter
14     def eat(self,food):
15         print("set to food:",food)
16         self.__food = food
17     @eat.deleter
18     def eat(self):
19         del self.__food
20         print("刪完了")
21 
22 d = Dog("ChenRonghua")
23 d.eat
24 d.eat="baozi"
25 d.eat
26 del d.eat
27 d.eat

類的特殊方法
- __doc__ #表示類的描述信息，即類開頭的註釋信息
- __module__ #表示當前操做系統的對象在哪一個模塊
- __class__ #表示當前操做的對象的類是什麼
```
 1 aa.py
 2 
 3 class C:
 4 
 5     def __init__(self):
 6         self.name = 'alex'
 7 
 8 index.py
 9 
10 from lib.aa import C
11 obj = C()
12 print(obj.__module__)  # 輸出 lib.aa，即：輸出模塊
13 print(obj.__class__ )     # 輸出 lib.aa.C，即：輸出類
```
- __init__ #構造方法，經過類建立對象時，自動觸發執行
- __del__ #析構方法，當對象在內存中被釋放時，自動觸發執行。
- __call__ #對象後面加（），觸發執行。構造方法的執行是由建立對象觸發的，即：對象 = 類名() ；而對於 __call__方法的執行是由對象後加括號觸發的，即：對象() 或者類()()
```
 1 class Foo:
 2     def __init__(self):
 3         pass
 4      
 5     def __call__(self, *args, **kwargs):
 6  
 7         print '__call__'
 8  
 9 obj = Foo() # 執行 __init__
10 obj()       # 執行 __call__
```
- __dict__ #查看類或對象中的全部成員。經過類調用，輸出的是類裏的全部屬性，不包括實例屬性。經過實例調用，打印全部實例屬性，不包括類屬性
- __str__ #若是一個類中定義了__str__方法，那麼在打印對象時，默認輸出該方法的返回值
- __getitem__ 、__setitem__、__delitem__ #用於索引操做，如字典，分別表示獲取、設置、刪除數據
- __new__、__metaclass__ #https://www.cnblogs.com/alex3714/articles/5213184.html
  - 類的起源與metaclass
```
 1 def func(self):
 2     print('hello %s' %self.name)
 3 def __init__(self,name,age):
 4     self.name = name
 5     self.age = age
 6 
 7 Foo = type('Foo', (object,), {'talk': func,
 8                        '__init__':__init__})
 9 f = Foo("Chrn",22)
10 f.talk()
11 print(type(Foo))
```
  - 類的生成調用順序依次是 __new__ --> __init__ --> __call__

反射 #經過字符串映射或修改程序運行時的狀態、屬性、方法，有如下四種方法：

getattr(object, name_str, default=None) #根據字符串name_str去獲取object對象裏的對應的方法的內存地址
hasattr(object,name_str) #判斷一個對象object裏是否有對應的name_str字符串的方法
setattr(object,name_str,new_func) #在實例object中添加名字爲name_str的方法new_func函數

delattr(object,name_str) #刪除對象object中的方法name_str

 1 def bulk(self):
 2     print("%s is yelling...." %self.name)
 3 
 4 class Dog(object):
 5     def __init__(self,name):
 6         self.name = name
 7 
 8     def eat(self,food):
 9         print("%s is eating..."%self.name,food)
10 
11 d = Dog("NiuHanYang")
12 choice = input(">>:").strip()
13 
14 if hasattr(d,choice):  #判斷是否有choice輸入的這個方法
15     func=getattr(d,choice) #有，則調用類方法
16     func("chenronghua")
17 else:
18     setattr(d,choice,bulk) #給類添加新的方法bulk
19     func = getattr(d, choice) #調用剛剛添加的新方法
20     func(d)

異常處理

異常處理結構

 1 try:
 2     # 主代碼塊
 3     pass
 4 except KeyError,e:
 5     # 異常時，執行該塊
 6     pass
 7 else:
 8     # 主代碼塊執行完，執行該塊
 9     pass
10 finally:
11     # 不管異常與否，最終執行該塊
12     pass

 1 names = ['alex','jack']
 2 try:
 3     data['name']
 4 except KeyError as e : #每種錯入一種處理方法，若是前兩種處理方法同樣則except (KeyError,IndexError) as e，若是全部錯誤使用同一種處理方法則except Exception as e
 5     print("沒有這個key",e)
 6 except IndexError as e :
 7     print("列表操做錯誤",e)
 8 except BaseException as e: #除去以上兩種以外的其餘錯誤，或者在最後面使用Exception
 9     print("未知錯誤",e)
10 else:
11     print("一切正常")
12 finally:
13     print("無論有沒有錯，都執行")

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

自定義異常與主動觸發異常

格式

 1 #主動觸發異常
 2 try:
 3     raise Exception('錯誤了。。。')
 4 except Exception,e:
 5     print e
 6     
 7 #自定義異常
 8 class WupeiqiException(Exception):
 9  
10     def __init__(self, msg):
11         self.message = msg
12  
13     def __str__(self):
14         return self.message
15  
16 try:
17     raise WupeiqiException('個人異常')
18 except WupeiqiException,e:
19     print e

實例

1 class AlexError(Exception):
2     def __init__(self, msg):
3         self.message = msg
4         
5 try:
6     raise AlexError('數據庫連不上')
7 except AlexError as e:
8     print(e)

Scoket開發基礎

Socket介紹
- Socket Families(地址簇)
  - socket.AF_UNIX #unix本機進程間通訊
  - socket.AF_INET　#IPV4
  - socket.AF_INET6 #IPV6
- Socket Types
  - socket.SOCK_STREAM #for tcp
  - socket.SOCK_DGRAM #for udp
  - socket.SOCK_RAW #原始套接字，普通的套接字沒法處理ICMP、IGMP等網絡報文，而SOCK_RAW能夠；其次，SOCK_RAW也能夠處理特殊的IPv4報文；此外，利用原始套接字，能夠經過IP_HDRINCL套接字選項由用戶構造IP頭
  - socket.SOCK_RDM #是一種可靠的UDP形式，即保證交付數據報但不保證順序。SOCK_RAM用來提供對原始協議的低級訪問，在須要執行某些特殊操做時使用，如發送ICMP報文。SOCK_RAM一般僅限於高級用戶或管理員運行的程序使用
Socket參數介紹

實例

客戶端

 1 #客戶端
 2 import socket
 3 
 4 client = socket.socket() #聲明socket類型，同時生成socket鏈接對象
 5 client.connect(('localhost',6969))
 6 
 7 while True:
 8     msg = input(">>:").strip()
 9     if len(msg) == 0:continue
10     client.send(msg.encode("utf-8"))
11     data = client.recv(1024) #一次最大接收1024個字節
12     print("recv:",data.decode())
13 
14 client.close()

服務端

 1 #服務器端
 2 import socket
 3 server = socket.socket()
 4 server.bind(('localhost',6969)) #綁定要監聽端口
 5 server.listen() #監聽
 6 
 7 print("我要開始等電話了")
 8 while True:
 9     conn, addr = server.accept()  # 等電話打進來
10     # conn就是客戶端連過來而在服務器端爲其生成的一個鏈接實例
11     print(conn, addr)
12     print("電話來了")
13     while True:
14         data = conn.recv(1024)
15         print("recv:",data)
16         if not data:  #接收到的數據爲空則斷開
17             print("client has lost...")
18             break
19         conn.send(data.upper())
20 
21 server.close()

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。