Python類三種方法，函數傳參，類與執行個體變量(一)

1 Python的函數傳遞：

首先所有的變量都可以了解為記憶體中一個對象的‘引用’

a = 1
def func(a):
    a = 2
func(a)
print(a) # 1

a = 1
def fun(a):
    print("函數裡",id(a))   # 函數裡 41322472
    a = 2
    print("指派後",id(a), id(2))   # 指派後 41322448 41322448
print("函數外",id(a), id(1))  # 函數外 41322472 41322472
fun(a)
print(a)  # 1           

可以看到，在執行完

a = 2

之後，

a

引用中儲存的值，即記憶體位址發生變化，由原來

1

對象的所在的位址變成了

2

這個實體對象的記憶體位址。下面我們來看另一個例子：

a = []
def fun(a):
    a.append(1)
fun(a)
print a  # [1]

a = []
def fun(a):
    print("函數裡",id(a))  # 函數裡 53629256
    a.append(1)
print("函數外",id(a))     # 函數外 53629256
fun(a)
print(a) # [1]           

注意：

1. 類型是屬于對象的，而不是變量。而對象有兩種,“可更改”（mutable）與“不可更改”（immutable）對象。
2. strings, tuples, 和numbers是不可更改的對象，而 list, dict, set 等則是可修改的對象。
3. 當一個引用傳遞給函數的時候,函數自動複制一份引用,這個函數裡的引用和外邊的引用沒有半毛關系了.是以第一個例子裡函數把引用指向了一個不可變對象number,當函數傳回的時候,外面的引用沒半毛感覺.而第二個例子就不一樣了,函數内的引用指向的是可變對象list,指向了清單的記憶體位址，是以調用并不會改變list記憶體位址.

2 python中元類

Python中的類也是對象。元類就是用來建立這些類（對象）的，元類就是類的類

MyClass = MetaClass()    #元類建立
MyObject = MyClass()     #類建立執行個體
實際上MyClass就是通過type()來建立出MyClass類，它是type()類的一個執行個體；同時MyClass本身也是類，也可以建立出自己的執行個體，這裡就是MyObject           

類就是建立類這種對象的東西， type就是Python的内建元類，當然了，你也可以建立自己的元類。

age = 35
age.__class__
#輸出：<type 'int'>
name = 'bob'
name.__class__
#輸出：<type 'str'>
def foo(): 
    pass
foo.__class__
#輸出：<type 'function'>
class Bar(object): 
    pass
b = Bar()
b.__class__
#輸出：<class '__main__.Bar'>

對于任何一個__class__的__class__屬性又是什麼呢？
a.__class__.__class__
#輸出：<type 'type'>
age.__class__.__class__
#輸出：<type 'type'>
foo.__class__.__class__
#輸出：<type 'type'>
b.__class__.__class__
#輸出：<type 'type'>           

3 靜态方法(@staticmethod)和類方法(@classmethod)

Python其實有3個方法,即靜态方法(staticmethod),類方法(classmethod)和執行個體方法

def foo(x): #正常方法
    print("executing foo(%s)"%(x))

class A(object):
    #執行個體方法
    def foo(self,x):  #預設第一個參數為執行個體對象
        print("executing foo(%s,%s)"%(self,x))
    #類方法
    @classmethod
    def class_foo(cls,x):  #預設第一個參數為類對象
        print ("executing class_foo(%s,%s)"%(cls,x))
    #靜态方法
    @staticmethod    #不需要綁定,調用注意
    def static_foo(x):
        print("executing static_foo(%s)"%x)
a=A()           

函數參數裡面的self和cls.這個self和cls是對執行個體或者類的綁定

1. 對于一般的函數來說我們可以這麼調用

   foo(x)

   ,這個函數就是最常用的,它的工作跟任何東西(類,執行個體)無關.
2. 對于執行個體方法,我們知道在類裡每次定義方法的時候都需要綁定這個執行個體,就是

   foo(self, x)

   ,因為執行個體方法的調用離不開執行個體,我們需要把執行個體自己傳給函數,調用的時候是這樣的

   a.foo(x)

   (其實是

   foo(a, x)

   ).
3. 類方法一樣,隻不過它傳遞的是類而不是執行個體,

   A.class_foo(x)

   .注意這裡的self和cls可以替換别的參數,但是python的約定是這倆
4. 對于靜态方法其實和普通的方法一樣,不需要對誰進行綁定,唯一的差別是調用的時候需要使用

   a.static_foo(x)

   或者

   A.static_foo(x)

   來調用.不管是 類調用，還是執行個體調用靜态方法，都是指向同一個函數對象

#	執行個體方法	類方法	靜态方法
a = A()	a.foo(x)	a.class_foo(x)	a.static_foo(x)
A	不可用	A.class_foo(x)	A.static_foo(x)

4 類變量與執行個體變量

類變量 ： 是可在類的所有執行個體之間共享的值（也就是說，它們不是單獨配置設定給每個執行個體的）。

執行個體變量 ： 執行個體化之後，每個執行個體單獨擁有的變量。

class Test(object):  
    num_of_instance = 0  #類變量
    def __init__(self, name):   #name就是執行個體變量
        self.name = name  
        Test.num_of_instance += 1  

if __name__ == '__main__':  
    print(Test.num_of_instance)   # 0
    t1 = Test('jack')  
    print(Test.num_of_instance)   # 1
    t2 = Test('lucy')  
    print(t1.name , t1.num_of_instance)  # jack 2
    print(t2.name , t2.num_of_instance)  # lucy 2

class Person:
    name="aaa"

p1=Person()
p2=Person()
p1.name="bbb"
print p1.name  # bbb
print p2.name  # aaa  對象名.屬性
print Person.name  # aaa  類名.屬性           

這裡

p1.name="bbb"

是執行個體調用了類變量,,類似函數傳參的問題,

p1.name

一開始是指向的類變量

name="aaa"

,但是在執行個體的作用域裡把類變量的引用改變了,就變成了一個執行個體變量,self.name不再引用Person的類變量name了。