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 = []
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)來調用.不管是 類調用，還是實例調用靜態方法，都是指向同一個函數對象

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了。

Python類三種方法，函數傳參，類與實例變量(一)