python类与函数编程_Python类三种方法，函数传参，类与实例变量(一)详解
1 Python的函數(shù)傳遞：
首先所有的變量都可以理解為內(nèi)存中一個對象的‘引用’
a = 1
def func(a):
a = 2
func(a)
print(a) # 1
a = 1
def fun(a):
print("函數(shù)里",id(a)) # 函數(shù)里 41322472
a = 2
print("賦值后",id(a), id(2)) # 賦值后 41322448 41322448
print("函數(shù)外",id(a), id(1)) # 函數(shù)外 41322472 41322472
fun(a)
print(a) # 1
可以看到，在執(zhí)行完a = 2之后，a引用中保存的值，即內(nèi)存地址發(fā)生變化，由原來1對象的所在的地址變成了2這個實體對象的內(nèi)存地址。下面我們來看另一個例子：
a = []
def fun(a):
a.append(1)
fun(a)
print a # [1]
a = []
def fun(a):
print("函數(shù)里",id(a)) # 函數(shù)里 53629256
a.append(1)
print("函數(shù)外",id(a)) # 函數(shù)外 53629256
fun(a)
print(a) # [1]
注意：
類型是屬于對象的，而不是變量。而對象有兩種,“可更改”(mutable)與“不可更改”(immutable)對象。
strings, tuples, 和numbers是不可更改的對象，而 list, dict, set 等則是可修改的對象。
當一個引用傳遞給函數(shù)的時候,函數(shù)自動復(fù)制一份引用,這個函數(shù)里的引用和外邊的引用沒有半毛關(guān)系了.所以第一個例子里函數(shù)把引用指向了一個不可變對象number,當函數(shù)返回的時候,外面的引用沒半毛感覺.而第二個例子就不一樣了,函數(shù)內(nèi)的引用指向的是可變對象list,指向了列表的內(nèi)存地址，因此調(diào)用并不會改變list內(nèi)存地址.
2 python中元類
Python中的類也是對象。元類就是用來創(chuàng)建這些類(對象)的，元類就是類的類
MyClass = MetaClass() #元類創(chuàng)建
MyObject = MyClass() #類創(chuàng)建實例
實際上MyClass就是通過type()來創(chuàng)建出MyClass類，它是type()類的一個實例；同時MyClass本身也是類，也可以創(chuàng)建出自己的實例，這里就是MyObject
類就是創(chuàng)建類這種對象的東西， type就是Python的內(nèi)建元類，當然了，你也可以創(chuàng)建自己的元類。
age = 35
age.__class__
#輸出：
name = 'bob'
name.__class__
#輸出：
def foo():
pass
foo.__class__
#輸出：
class Bar(object):
pass
b = Bar()
b.__class__
#輸出：
對于任何一個__class__的__class__屬性又是什么呢？
a.__class__.__class__
#輸出：
age.__class__.__class__
#輸出：
foo.__class__.__class__
#輸出：
b.__class__.__class__
#輸出：
3 靜態(tài)方法(@staticmethod)和類方法(@classmethod)
Python其實有3個方法,即靜態(tài)方法(staticmethod),類方法(classmethod)和實例方法
def foo(x): #常規(guī)方法
print("executing foo(%s)"%(x))
class A(object):
#實例方法
def foo(self,x): #默認第一個參數(shù)為實例對象
print("executing foo(%s,%s)"%(self,x))
#類方法
@classmethod
def class_foo(cls,x): #默認第一個參數(shù)為類對象
print ("executing class_foo(%s,%s)"%(cls,x))
#靜態(tài)方法
@staticmethod #不需要綁定,調(diào)用注意
def static_foo(x):
print("executing static_foo(%s)"%x)
a=A()
函數(shù)參數(shù)里面的self和cls.這個self和cls是對實例或者類的綁定
對于一般的函數(shù)來說我們可以這么調(diào)用foo(x),這個函數(shù)就是最常用的,它的工作跟任何東西(類,實例)無關(guān).
對于實例方法,我們知道在類里每次定義方法的時候都需要綁定這個實例,就是foo(self, x),因為實例方法的調(diào)用離不開實例,我們需要把實例自己傳給函數(shù),調(diào)用的時候是這樣的a.foo(x)(其實是foo(a, x)).
類方法一樣,只不過它傳遞的是類而不是實例,A.class_foo(x).注意這里的self和cls可以替換別的參數(shù),但是python的約定是這倆
對于靜態(tài)方法其實和普通的方法一樣,不需要對誰進行綁定,唯一的區(qū)別是調(diào)用的時候需要使用a.static_foo(x)或者A.static_foo(x)來調(diào)用.不管是 類調(diào)用，還是實例調(diào)用靜態(tài)方法，都是指向同一個函數(shù)對象
#
實例方法
類方法
靜態(tài)方法
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"是實例調(diào)用了類變量,,類似函數(shù)傳參的問題,p1.name一開始是指向的類變量name="aaa",但是在實例的作用域里把類變量的引用改變了,就變成了一個實例變量,self.name不再引用Person的類變量name了。
總結(jié)
以上是生活随笔為你收集整理的python类与函数编程_Python类三种方法，函数传参，类与实例变量(一)详解的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java api中最常用的五个包_jav
- 下一篇： Python程序开发——第一章 基本py