1、python传参问题
def fun(a):
a = 2
fun(a)
print(a) # 1
a = []
def fun(a):
a.append(1)
fun(a)
print(a) # [1]
关键：只需要记住类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而 list, dict, set 等则是可以修改的对象。（那么在传参之后，如果赋值对象的数据类型数可变的，参数值就会改变，而地址不会变；如果赋值对象数据类型数不可变的，原来的引用地址和值就不会变，但是赋值对象的地址和值是会变的）
例如： 下面a是列表，可变类型，在进行了a.append（）操作后，a的值改变，地址不变
a = []
def fun(a):
print( "func_in",id(a) # func_in 53629256
a.append(1)
print ("func_out",id(a)) # func_out 53629256
fun(a)
print(a) # [1]
再例如：下面a是numbers不可变类型，在进行a=2赋值操作，当时a指向了2这个地址，a地址就变成了2的地址，但是函数出来之后，a的地址还是回到了1地址并没有改变
a = 1
def fun(a):
print("func_in",id(a)) # func_in 41322472
a = 2
print ("re-point",id(a), id(2)) # re-point 41322448 41322448
print("func_out",id(a), id(1)) c# func_out 41322472 41322472
fun(a)
print a # 1
2、实例方法，类方法@classmethod和静态方法@staticmethod
先看一下：
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是对类或者实例的绑定,可以替换别的参数,但是python的约定是这俩,还是不要改的好.
（1）一般方法，我们可以这么调用foo(x),这个函数就是最常用的,它的工作跟任何东西(类,实例)无关。
（2）实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例,就是foo(self, x)，调用时：a.foo(x) (本质其实是foo(a, x))
（3）类方法一样,只不过它传递的是类而不是实例,A.class_foo(x)。
（4）静态方法，其实和普通的方法一样,不需要对谁进行绑定,唯一的区别是调用的时候需要使用a.static_foo(x)或者A.static_foo(x)来调用.
image.png
3、类变量和实例变量
类变量：
是可在类的所有实例之间共享的值（也就是说，它们不是单独分配给每个实例的）。例如下例中，num_of_instance 就是类变量，用于跟踪存在着多少个Test 的实例。
实例变量：
实例化之后，每个实例单独拥有的变量。
class Test(object):
num_of_instance = 0
def __init__(self, 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
这里name就是类变量，参考上面讲的传参问题，因为“aaa”是字符串类型，所以实例p1调用这个类变量，并不会改变类变量本身的地址，所以实例p2调用时，变量值并不会变，而如果类变量类型是可变的，调用他，变量值就会改变但是地址不会变，看下面的例子：
class Person:
name=[]
p1=Person()
p2=Person()
p1.name.append(1)
print(p1.name) # [1]
print( p2.name) # [1]
print( Person.name) # [1]
4、Python自省
这个也是python彪悍的特性.
自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.不用定义，赋什么类型的值它就会是什么类型的变量，比如type(),dir(),getattr(),hasattr(),isinstance().
a = [1,2,3]
b = {'a':1,'b':2,'c':3}
c = True
print(type(a),type(b),type(c)) # <type 'list'> <type 'dict'> <type 'bool'>
print(isinstance(a,list)) # True
网友评论