成員變量

對象的創建

創建對象的過程稱之為實例化，當一個對象被創建後，包含三個方面的特性對象聚丙屬性和方法，
句柄用於區分不同的對象，
對象的屬性和方法，與類中的成員變量和成員函數對應，
obj = MyClass()創建類的一個實例，擴號對象，通過對象來調用方法和屬性

類的屬性

類的屬性按使用範圍分為公有屬性和私有屬性類的屬性範圍，取決於屬性的名稱，
**共有屬性**---在內中和內外都能夠調用的屬性
**私有屬性**---不能在內外貝類以外函數調用
定義方式:以"__"雙下劃線開始的成員變量就是私有屬性
可以通過instance.__classname__attribute方式訪問，
內置屬性--由系統在定義類的時候默認添加的由前後雙下劃線構成，如__dic__,__module__
 

#!/usr/bin/env python
#-*- coding:utf-8  -*-
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

ren = People()
ren.color = ‘白色人‘
print ren.color
ren.think()
print ‘#‘*30
print("People.color")
print ren.__People__age  ##測試時使用。如要調用 時，通過方法內調用 。
 

2.類的方法

成員函數

類的方法
方法的定義和函數一樣，但是需要self作為第一個參數.
類方法為:
    公有方法
    私有方法
    類方法
    靜態方法

公有方法：在類中和類外都都測調用的方法.
私有方法：不測被類的外部調用模塊，在方法前加個“__”c雙下劃線就是私有方法。
self參數：
    用於區分函數和類的方法(必須有一個self)
    self參數表示執行對象本身

#!/usr/bin/env python
#-*- coding:utf-8  -*-
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 test(self):

self.think() # 內部調用
jack = People()
jack.test()    #外部調用
 

#!/usr/bin/env python
#-*- coding:utf-8  -*-
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"

 def test(self):
self.__talk() # 內部調用talk()

jack = People()
jack.test()    #外部調用

類方法
類方法：被classmethod()函數處理過的函數,能被類所調用，也能被對象所調用（是繼承的關系）。

靜態方法：相當於“全局函數”，可以被類直接調用，可以被所有實例化對象共享，通過staticmethod()定義靜態方法，    靜態方法沒有self參數

裝飾器:
    @classmethod()
    @staticmethod()

#!/usr/bin/env python
#-*- coding:utf-8  -*-
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"

 def test(self):
print ‘Testing....‘

  cm = classmethod(test)

jack = People()
People.cm()

通過類方法類內的方法 ，不涉及的屬性和方法 不會被加載，節省內存，快。

#!/usr/bin/env python
#-*- coding:utf-8  -*-
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"

 def test():   ##沒有self   靜態調用     會把所有的屬性加載到內存裏。
print People.__age   #  通過類訪問內部變量

  sm = staticmethod(test)

jack = People()
People.sm()

裝飾調用類的方法：

#!/usr/bin/env python
#-*- coding:utf-8  -*-
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")

jack = People()
People.test()
People.test1()

3.類的內置方法

Python內部類：

所謂內部類，就是在類的內部定義的類，主要目的是為了更好的抽象現實世界。
例子：
汽車是一個類，汽車的底盤輪胎也可以抽象為類，將其定義到汽車內中，而形成內部類，
更好的描述汽車類，因為底盤輪胎是汽車的一部分。

內部類實例化方法：

方法1：直接使用外部類調用內部類
方法2：先對外部類進行實例化，然後再實例化內部類
out_name = outclass_name()
in_name = out_name.inclass_name()
in_name.method()

#!/usr/bin/env python
#-*- coding:utf-8  -*-
class People(object):
    color = ‘yellow‘
    __age = 30   #私有屬性

    class Chinese(object):
        print("I am chinese")

    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")

jack = People.Chinese()

#!/usr/bin/env python
#-*- coding:utf-8  -*-
class People(object):
    color = ‘yellow‘
    __age = 30   #私有屬性

    class Chinese(object):
        name ="I am a Chinese."

    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")

jack = People.Chinese()  #外部類調用內部類
print jack.name     #外部類調用內部類對象

另一種方法，外部類調用內部類對象
#!/usr/bin/env python
#-*- coding:utf-8  -*-
class People(object):
    color = ‘yellow‘
    __age = 30   #私有屬性

    class Chinese(object):
        name ="I am a Chinese."

    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")

ren = People()            #實例化外部類
jack = ren.Chinese()   #實例化內部類
print jack.name           #打印內部類屬性

或
print People.Chinese.name
print People.Chinese().name

魔術方法：

str(self)
構造函數與析構函數
構造函數:

    用於初始化類的內部狀態，Python提供的構造函數是__init__():
    __init__():方法是可選的，如果不提供，python會給出一個默認的__init__方法。

析構函數：

    用於釋放對象占用的資源，python提供的析構函數是__del__():
    __del__():也是可選的，如果不提供，則python會在後臺提供默認析構函數。

構造函數__str__

#!/usr/bin/env python
#-*- coding:utf-8  -*-
class People(object):
    color = ‘yellow‘
    __age = 30   #私有屬性

    class Chinese(object):
        name ="I am a Chinese."

    def __str__(self):
        return "This is People class"

    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")

ren = People()            #實例化外部類
print ren     #默認執行__str__

__init__(self)初始化類：

#!/usr/bin/env python
#-*- coding:utf-8  -*-
class People(object):
    color = ‘yellow‘
    __age = 30   #私有屬性

    class Chinese(object):
        name ="I am a Chinese."

    def __str__(self):
        return "This is People class"

    def __init__(self,c=‘white‘):   #類實例化時自動執行
        self.color = c
 self.think()

    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")

jack = People(‘green‘)
ren = People()            #實例化外部類
print ren.color        #通過對象訪問屬性是初始化後的值
print People.color    #通過類訪問還是原來的值   

[root@localhost 20180110]# python test1.py 
I am a black 
I am a thinker
30
black
yellow

析構函數__del__()：釋放資源

#!/usr/bin/env python
#-*- coding:utf-8  -*-
class People(object):
    color = ‘yellow‘
    __age = 30   #私有屬性

    class Chinese(object):
        name ="I am a Chinese."

    def __str__(self):
        return "This is People class"

    def __init__(self,c=‘white‘):   #類實例化時自動執行
        print ("initing...")
 self.color = c
        self.think()
        f = open(‘test.py‘)

    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.f.close()

jack = People(‘green‘)
ren = People()            #實例化外部類
print ren.color        #通過對象訪問屬性是初始化後的值
print People.color    #通過類訪問還是原來的值   

垃圾回收機制：

Python采用垃圾回收機制來清理不再使用的對象;python提供gc模塊釋放不再使用的對象。
Python采用“引用計數”的算法方式來處理回收，即：當然某個對象在其作用域內不再被其
他對象引用的時候，python就自動化清除對象。
gc模塊collect()可以一次性收集所有待處理的對象(gc.collect)

#!/usr/bin/env python
#-*- coding:utf-8  -*-
class People(object):
    color = ‘yellow‘
    __age = 30   #私有屬性

    class Chinese(object):
        name ="I am a Chinese."

    def __str__(self):
        return "This is People class"

    def __init__(self,c=‘white‘):   #類實例化時自動執行
        print ("initing...")
                 self.color = c
        self.think()
        f = open(‘test.py‘)

    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.f.close()

print gc.collect()     如果是0是沒有回收的。
jack = People(‘green‘)
ren = People()            #實例化外部類
print ren.color        #通過對象訪問屬性是初始化後的值
print People.color    #通過類訪問還是原來的值   

Python中類的屬性、方法及內置方法