一、私有化
- xx :公开属性
class Test(object):
def __init__(self):
#这是一个公开属性
self.num = 100
from a import *
test = Test()
print(test.num)
- _xx :模块内可以访问的属性
这个的作用是该属性只能在当前模块中使用,出了模块及不能使用
class Test(object):
def __init__(self):
#这是一个模块属性
self._num = 100
test = Test()
print(test._num)
- __xx :通常是类的私有属性
class Test(object):
def __init__(self):
#这是一个私有属性
self.__num = 100
#当前模块中Test类可以访问
那该怎么访问这个类的私有属性呢,看下面就明白了:
class Test(object):
def __init__(self):
self.__num = 100
def setNum(self, newNum):
self.__num = newNum
def getNum(self):
return self.__num
- xx:系统自带属性或方法
xx:双前后下划线,用户名字空间的魔法对象或属性。例如:init , __ 不要自己发明这样的名字 - xx_ : 用户和系统关键系重名,避免冲突
这个看到就更少了,没人闲的无聊用系统的关键字作为变量,但是你硬要这么干,可以用xx_.
test = Test()
test.if_ = 10
二、==和is
>>> a = 1
>>> b = 1.0
>>> a is b
False
>>> a == b
True
>>> id(a)
12777000
>>> id(b)
14986000
>>> a = 1
>>> b = 1
>>> a is b
True
>>> a == b
True
>>> id(a)
12777000
>>>id(b)
12777000
三、深拷贝和浅拷贝
- 浅拷贝
浅拷贝是对于一个对象的顶层拷贝
通俗的理解是：拷贝了引用，并没有拷贝内容
In [10]: a = [11,22,33]
In [11]: b = a
In [12]: id(a)
Out[12]: 140343572333832
In [13]: id(b)
Out[13]: 140343572333832
In [14]: a[0] = 'aa'
In [15]: a
Out[15]: ['aa', 22, 33]
In [16]: b
Out[16]: ['aa', 22, 33]
当b = a时，实际上是将a列表的内存地址赋值给了b，那么变量a与变量b指向的是同一内存地址！
- 深拷贝
深拷贝是对于一个对象所有层次的拷贝(递归)
In [17]: import copy
In [18]: c = copy.deepcopy(a)
In [19]: id(a)
Out[19]: 140343572333832
In [20]: id(c)
Out[20]: 140343572336840
In [21]: a
Out[21]: ['aa', 22, 33]
In [22]: c
Out[22]: ['aa', 22, 33]
In [23]: a[0] = 11
In [24]: a
Out[24]: [11, 22, 33]
In [25]: c
Out[25]: ['aa', 22, 33]
深拷贝不仅拷贝引用还拷贝值，所以内存地址不一样！
四、列表的推倒式
- 列表的推导是为了更加简洁的去创建一个list
- 列表推到格式
nums = list(item for item in range(1, 10))
print(nums)
结果
[1, 2, 3, 4, 5, 6, 7, 8, 9]
五、生成器
def count(n):
x = 0
while x < n:
yield x
x += 1
for i in count(5):
print i
迭代器
class CountIter:
def __init__(self, n):
self.n = n
def __iter__(self):
self.x = -1
return self
def next(self): # For Python 2.x
self.x += 1
if self.x < self.n:
return self.x
else:
raise StopIteration
for i in CountIter(5):
print i
六、闭包
其实，闭包的定义就是一个函数内部又嵌套了一个函数
来看下面的这段代码
def foo():
print("hello world in foo")
name="python"
def bar():
print(name)
print("hello world in bar")
return bar
f1=foo()
f1()
七、装饰器
@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作
这是一个带有参数的装饰器
import time
def deco(func):
def wrapper(a,b):
startTime = time.time()
func(a,b)
endTime = time.time()
msecs = (endTime - startTime)*1000
print("time is %d ms" %msecs)
return wrapper
@deco
def func(a,b):
print("hello，here is a func for add :")
time.sleep(1)
print("result is %d" %(a+b))
if __name__ == '__main__':
f = func
f(3,4)
#func()