一、私有化

1. xx :公开属性

class Test(object):
    def __init__(self):
        #这是一个公开属性
        self.num = 100

from a import *
test = Test()
print(test.num)

2. _xx :模块内可以访问的属性
   这个的作用是该属性只能在当前模块中使用,出了模块及不能使用

class Test(object):
    def __init__(self):
        #这是一个模块属性
        self._num = 100

test = Test()
print(test._num)

3. __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

4. xx:系统自带属性或方法
   xx:双前后下划线,用户名字空间的魔法对象或属性。例如:init , __ 不要自己发明这样的名字
5. 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

三、深拷贝和浅拷贝

1. 浅拷贝
   浅拷贝是对于一个对象的顶层拷贝
   通俗的理解是：拷贝了引用，并没有拷贝内容

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指向的是同一内存地址！

2. 深拷贝
   深拷贝是对于一个对象所有层次的拷贝(递归)

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]

深拷贝不仅拷贝引用还拷贝值，所以内存地址不一样！

四、列表的推倒式

1. 列表的推导是为了更加简洁的去创建一个list
2. 列表推到格式

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()