Python第九天 面向對象 類定義 類的屬性 類的方法 內部類 垃圾回收機制 類的繼承
目錄
Python第二天 變量 運算符與表達式 input()與raw_input()區別 字符編碼
Python第三天 序列 數據類型 數值 字符串 列表 元組 字典
Python第四天 流程控制 ifelse條件判斷 forwhile循環
Python第五天 文件訪問 for循環訪問文件 while循環訪問文件 字符串的startswith函數和split函數
Python第七天 函數 函數參數 函數變量 函數返回值 多類型傳值 冗余參數 函數遞歸調用 匿名函數 內置函數 列表表達式/列表重寫
Python第八天 模塊 包 全局變量和內置變量__name__ Python path
Python第九天 面向對象 類定義 類的屬性 類的方法 內部類 垃圾回收機制 類的繼承
Python第十天 print >> f,和fd.write()的區別 stdout的buffer 標準輸入 標準輸出 標準錯誤 重定向
Python第十二天 收集主機信息 正則表達式 正則表達式 無名分組 有名分組
Python第十四天 序列化 pickle模塊 cPickle模塊 JSON模塊 API的兩種格式
面向對象
類和對象
Python類定義
類屬性
類方法
面向過程和面向對象編程
- 面向過程編程：函數式編程，C程序等
- 面向對象編程：C++,Java,Python等
str. ->顯示字符串的方法，屬性
list. ->顯示列表的方法，屬性
tuple. ->顯示元組的方法，屬性
dict. ->顯示字典的方法，屬性
面向對象的主要思想是：
- 封裝
- 繼承
- 多態
這種思想方便解決較為復雜的項目，且維護起來較為容易。
-----------------------------------------
Python類定義
類定義：
類把需要的變量和函數組合成一起，這種包含稱為“封裝”
class A(object): 繼承object這個類，跟C#一樣，object是根對象
類的結構：
class 類名:
成員變量 – 屬性
成員函數 – 方法
類名：每個單詞首字母大寫
函數名：第二個單詞開始首字母大寫
class MyClass(object):
def fun(self):
print "I am function"
類的方法中至少有一個參數self，self表示類本身
定義類有2中方法
一種是不加(object) class A():
一種是加(object) class A(object):
前者是傳統的定義方法，后者是新的風格，建議使用后者，super這個內置函數支持新風格定義的類。
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
__age = 30
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a " + self.color
print "I am a thinker"
print self.__age
ren = People()
ren.color = '白色人'
print ren.color
ren.think()
print ren.__dict__
print '#' *30
print People.color
print '#' *30
print People.__dict__
-----------------------------------------
對象的創建
創建對象的過程稱之為實例化；當一個對象被創建后，包含三個方面的特性：對象句柄、屬性和方法。
句柄用于區分不同的對象
對象的屬性和方法與類中的成員變量和成員函數對應
obj = MyClass() //創建類的一個實例(對象)
通過對象來調用方法和屬性
-----------------------------------------
類的屬性
類的屬性按使用范圍分為公有屬性和私有屬性，類的屬性范圍取決于屬性的名稱。
- 公有屬性：在類中和類外都能調用的屬性。
公有屬性可以不用實例化對象就可以訪問，classname.attribute，print People.color
- 私有屬性：不能在類外及被類以外的函數調用。 定義方式：以”__”雙下劃線開始的成員變量就是私有屬性，可以通過instance._classname__attribute方式訪問，print ren._People__age
實例化對象名._類名__私有屬性名
- 內置屬性：由系統在定義類的時候默認添加的，由前后雙下劃線構成，__dict__, __module__。
實例化對象.__dict__ :只能訪問公有屬性
類名.__dict__ ：可以訪問私有屬性
靜態屬性和動態屬性
實例化對象之后調用的屬性是動態屬性，可以修改屬性值
ren = People()
ren.color = '白色人'
print ren.color
沒有實例化對象用類名直接調用的屬性是靜態屬性，不能修改
print People.color
-----------------------------------------
類的方法
方法的定義和函數一樣，但是需要self作為第一個參數。
類方法為：
- 公有方法
- 私有方法
- 類方法
- 靜態方法
- 內置方法
公有方法：在類中和類外都能調用的方法。
私有方法：不能被類的外部調用，在方法前面加上”__”雙下劃線就是私有方法。
self參數：用于區分函數和類的方法(必須有一個self)，self參數表示執行對象本身。
內置方法：由系統在定義類的時候默認添加的，由前后雙下劃線構成，__str__(self)， __init__(self)
類方法：被classmethod()函數處理過的函數，能被類所調用，也能被對象所調用(是繼承的關系)
classmethod(函數名)
classmethod(test) test是一個方法
def test(self):
print self.color
cm = classmethod(test)
People.cm()
靜態方法：相當于”全局函數”，可以被類直接調用，可以被所有實例化對象共享，通過staticmethod()定義，靜態方法沒有”self”參數。
def test():
print People.color 訪問類里面屬性
sm = staticmethod(test)
People.sm()
裝飾器：
- @classmethod
- @staticmethod
靜態方法和動態方法
實例化對象之后調用的方法是動態方法，有一個例外，類方法classmethod(函數名)是動態方法，可以訪問實例里的屬性
沒有實例化對象staticmethod() 直接調用的方法是靜態方法
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
__age = 30
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a thinker"
print self.__age
def __talk(self):
print "I am talking with Tom"
@classmethod
def test(self):
print "this is class method"
@staticmethod
def test1():
print "this is static method"
cm = classmethod(test)
People.cm()
jack = People()
People.test()
People.test1()
-----------------------------------------
Python內部類
在類的內部定義的類，主要目的是為了更好的抽象現實世界
內部類的實例化方法
方法1：直接使用外部類調用內部類
object_name = outclass_name.inclass_name()
方法2：先對外部類進行實例化，然后再實例化內部類
out_name = outclass_name()
in_name = out_name.inclass_name()
in_name.method()
--------------------------------------------------------
魔術方法/類內置方法
跟內置屬性一樣，類也有內置方法
__str__(self)
構造函數與析構函數
- 構造函數：
用于初始化類的內部狀態，Python提供的構造函數是__init__()；
__init__()方法是可選的，如果不提供，Python會給出一個默認的__init__方法
初始化傳參
def __init__(self, c='white'):
print "Init..."
self.color = c
self.think()
self.fd = open('/etc/hosts')
- 析構函數：
用于釋放對象占用的資源，Python提供的析構函數是__del__();
__del__()也是可選的，如果不提供，則Python會在后臺提供默認析構函數
-----------------------------------------
垃圾回收機制
Python采用垃圾回收機制來清理不再使用的對象；python提供gc模塊釋放不再使用的對象。
Python采用”引用計數”的算法方式來處理回收，即：當某個對象在其作用域內不再被其他對象引用的時候，python就自動清除對象；
gc模塊的collect()函數可以一次性收集所有待處理的對象(gc.collect)
import gc
print gc.collect()
示例腳本
#!/usr/bin/python
#-*- coding:utf8 -*-
import gc
class People(object):
color = 'yellow'
__age = 30
class Chinese(object):
name = "I am chinese"
def __str__(self):
return "This is People class"
def __init__(self, c='white'):
print "Init..."
self.color = c
self.think()
self.fd = open('/etc/hosts')
def think(self):
self.color = "black"
print "I am a %s" % self.color
print "I am a thinker"
print self.__age
def __talk(self):
print "I am talking with Tom"
@classmethod
def test(self):
print "this is class method"
@staticmethod
def test1():
print "this is static method"
def __del__(self):
print "Del..."
self.fd.close()
print gc.collect()
jack = People('green')
print jack.color
print People.color
print 'Main end'
print gc.collect()
-----------------------------------------
類的繼承
繼承是面向對象的重要特性之一；
繼承關系：繼承是相對兩個類而言的父子關系，子類繼承了父類的所有公有屬性和方法
繼承實現了代碼重用。
繼承可以重用已經存在的數據和行為，減少代碼的重復編寫。
Python在類名后使用一對括號來表示繼承關系，括號中的類即為父類。
class Myclass(ParentClass)
如果父類定義了__init__方法，子類必須顯式調用父類的__init__方法：
ParentClass.__init__(self, [args…])
如果子類需要擴展父類的行為，可以添加__init__方法的參數。
示例1
class A:
def __init__(self):
print "enter A"
print "leave A"
class B(A):
def __init__(self):
print "enter B"
A.__init__(self)
print "leave B"
b = B()
輸出：
enter B
enter A
leave A
leave B
class A:
def __init__(self):
print "enter A"
print "leave A"
class B(A):
def __init__(self):
print "enter B"
#A.__init__(self)
print "leave B"
b = B()
輸出：
enter B
leave B
class A:
def __init__(self):
print "enter A"
print "leave A"
class B(A):
print 'ccc'
b = B()
輸出：
ccc
enter A
leave A
示例2
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
def __init__(self, c):
print "Init..."
self.dwell = 'Earth'
def think(self):
print "I am a %s" % self.color
print "I am a thinker"
class Chinese(People):
def __init__(self):
#super(Chinese, self).__init__('red')
People.__init__(self, 'red')
def think(self):
print "I like talking"
cn = Chinese()
cn.think()
super函數
class A(object):
def __init__(self):
print "enter A"
print "leave A"
class B(A):
def __init__(self):
print "enter B"
super(B, self).__init__()
print "leave B"
b = B()
多重繼承
Python支持多重繼承，即一個類可以繼承多個父類；
語法：
class class_name(Parent_c1, Parent_c2,…)
注意：
當父類中出現多個自定義的__init__方法時，多重繼承只執行第一個類的__init__方法，其他不執行。
#!/usr/bin/python
#-*- coding:utf8 -*-
class People(object):
color = 'yellow'
def __init__(self):
self.dwell = 'Earth'
self.color = 'yellow'
def think(self):
print "I am a %s" % self.color
print "My home is %s" % self.dwell
class Martian(object):
color = 'red'
def __init__(self):
self.dwell = 'Martian'
def talk(self):
print "I like talking"
class Chinese(Martian, People):
def __init__(self):
People.__init__(self)
cn = Chinese()
cn.think()
cn.talk()
print cn.__dict__
-----------------------------------------
類的屬性-總結
類屬性，也是共有屬性
類的私有屬性
對象的共有屬性
對象的私有屬性
內置屬性
函數的局部變量
全局變量
#!/usr/bin/python
#coding:utf8
var5 = "全局變量 var5"
class MyClass(object):
var1 = '類屬性，類的公有屬性 var1'
__var2 = '類的私有屬性 __var2'
def func1(self):
self.var3 = '對象的公有屬性 var3'
self.__var4 = '對象的私有屬性 __var4'
var5 = '函數的局部變量 var5'
print self.__var4
print var5
def func2(self):
print self.var1
print self.__var2
print self.var3
print self.__var4
print var5
mc = MyClass()
mc.func1() #要訪問var3 這個對象公有屬性要先執行一下func1這個方法
print '*' * 50
mc.func2()
print '*' * 50
print mc.__dict__
print '*' * 50
print MyClass.__dict__
類的方法-總結
公有方法
私有方法
類方法 --動態 @classmethod
靜態方法 --靜態 @staticmethod
內置方法
#!/usr/bin/python
#coding:utf8
class MyClass(object):
name = 'Test'
def __init__(self):
self.func1()
self.__func2()
self.classFun()
self.staticFun()
def func1(self):
print self.name,
print "我是公有方法"
#self.__func2()
def __func2(self):
print self.name,
print "我是私有方法"
@classmethod
def classFun(self):
print self.name,
print "我是類方法"
@staticmethod
def staticFun():
print MyClass.name,
print "我是靜態方法"
mc = MyClass()
函數/方法、類、模塊的幫助
In [1]: help('aa'.strip())
no Python documentation found for 'aa'
需要把后面的括號去掉，即這樣：help('aa'.strip)
如果帶括號是看'aa'.strip()的返回結果幫助了 help('aa'.strip())。
所有看函數/方法、類、模塊的幫助都不需要后面的括號。
S.strip([chars]) -> string or unicode 去除前后的空格和換行符，制表符，\t \n
Return a copy of the string S with leading and trailing whitespace removed.
文章列表
| 不含病毒。www.avast.com |
