2017.7.24总结

1、深拷贝与浅拷贝
浅拷贝是对于一个对象的顶层拷贝，拷贝了引用，没有拷贝内容。

a = [11,22,33]
b = a
id(a)
id(b)

深拷贝是对于一个对象所有层次的拷贝。

import copy
a =[11,22,33]
b = copy.deepcopy(a)

如果拷贝对象不可变，深拷贝=浅拷贝

2、属性property使用方法
@property可将方法转为只读，实现一个属性的设置与读取

class Test:
         def __init__(self):  
                 self.__name = None
         @property
         def name(self):
               return self.__name
         @name.setter
         def name_set(self,value):
                self.__name = value

3、生成器
方法一：

L = [x for x in range(10)] 改为
G = (x for x in range(10))
next(G)

方法二：

def fib(times):
     n = 0
     a,b = 0,1
     while n<times:
          yield b
          a,b = b,a+b
          n+=1
     return 'done'

方法三：
利用send
执行到yield时，gen函数作用暂时保存，返回i的值;temp接收下次c.send("python")，send发送过来的值，c.next()等价c.send(None)

def gen():
    i = 0
    while i<5:
        temp = yield i
    print(temp)
    i+=1
def gen():
    i = 0
    while i<5:
        temp = yield i
    print(temp)
    i+=1
    
f = gen()
print(f.send(None))

4、动态语言
概念：动态编程语言是高级程序设计语言的一个类别，在计算机科学领域已被广泛应用。它是一类 在运行时可以改变其结构的语言 ：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。
（1）在运行过程中给对象添加属性

class Test:
        def __init__(self,name):
             self.name = name

test = Test('zhangsan')
test.age = 18

（2）在运行过程中给类添加属性

class Test:
        def __init__(self,name):
             self.name = name

Test.age = 18

(3)在运行过程中给类添加方法

class Test:
        def __init__(self,name):
             self.name = name
def run():
      print('running......')

#类方法
@classmethod
def run(cls):
      print('running.....')

#静态方法
@staticmethod
def run():
      print('running.......')

test = Test('zhangsan')

#添加实例方法
import types
test.run = types.MethodType(run,test)

#添加类方法
Test.run = run

#添加静态方法
Test.run = run

5、slots限制能添加的属性

class Student：
        __slots__ = ('name','age')

6、元类
type创建类
type可以像这样工作：
type(类名, 由父类名称组成的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

Test2 = type("Test2",(),{})

Foo = type('Foo', (), {'bar':True})

>>> class Foo(object):
…       bar = True

7、垃圾回收
（1）小整数池
Python 对小整数的定义是 [-5, 257) 这些整数对象是提前建立好的，不会被垃圾回收。在一个 Python 的程序中，所有位于这个范围内的整数使用的都是同一个对象.
（2）大整数池
每一个大整数，均创建一个新的对象。
（3）intern机制
python中有这样一个机制——intern机制，让他只占用一个”HelloWorld”所占的内存空间。靠引用计数去维护何时释放。

总结：
小整数[-5,257)共用对象，常驻内存
单个字符共用对象，常驻内存
单个单词，不可修改，默认开启intern机制，共用对象，引用计数为0，则销毁

8、内建函数
map：根据函数对指定序列映射

def f1( x, y ):  
    return (x,y)
l1 = [ 0, 1, 2, 3, 4, 5, 6 ]  
l2 = [ 'Sun', 'M', 'T', 'W', 'T', 'F', 'S' ]
l3 = map( f1, l1, l2 ) 
print(list(l3))

filter：函数会对指定序列执行过滤操作

filter(lambda x: x%2, [1, 2, 3, 4])
[1, 3]

reduce：reduce函数会对参数序列中元素进行累积

reduce(lambda x, y: x+y, [1,2,3,4], 5)
15