python知识

python小知识

1.python中xrange是生成的一个生成器，range返回的是一个列表。

2.python中缺省参数的陷阱：

def f(x, l=[]):
for i in range(x):
    l.append(i+i)
print(l)
f(3)
f(3,[3,2,1])
f(2)
输出：
# 第一个，第二个输出输出没有争议
[0, 2, 4]
[3, 2, 1, 0, 2, 4]
# 第三个输出，是没有传递参数，python中缺省参数值作用一次，下次在调用，会使用上次传递的参数当作缺省参数，就把第一次的结果传递了
[0, 2, 4, 0, 2]

3.另一个例子：

def outer():
  res = []
  for i in range(4):
    def inner(j):
      return j * i
    res.append(inner)
  return res

print [m(2) for m in outer()]

# 输出：
[6,6,6,6]
# 这是由于闭包的延迟，调用m(2)的时候，上面的i已经是3了。

python的内存管理：

一对象的引用计数机制,二垃圾回收机制,三内存池机制

一、对象的引用计数机制
Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。

引用计数增加的情况：

• 1，一个对象分配一个新名称

• 2，将其放入一个容器中（如列表、元组或字典）

引用计数减少的情况：

• 1.使用del语句对对象别名显示的销毁

• 2.引用超出作用域或被重新赋值
  sys.getrefcount( )函数可以获得对象的当前引用计数
  多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。

二、垃圾回收
- 1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
- 2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。

三、内存池机制
Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
- 1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
- 2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。
- 3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

python中字典推导式

dict = {key：value,for (key, value) in interable}

python中的单利模式

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not _istance:
            cls._instance = object.__new__(cls)
        return cls._instance
single = Singleton()

python中几个内置函数

1.map函数：

# 对后面的列表的逐个执行前面的函数：x + 1
a = map(lambda x:x+1,[for i in range(4)])
list(a)
>>[1,2,3,4]

2.filter函数：

# 返回的是满足条件的元素的列表
a = filter(lambda x: x > 3, [1,2,3,4,5,6])
print a 
>>[4,5,6]

3.reduce函数：
# 对列表中的数据进行累加，如果5不存在，默认为0
a = reduce(lambda x,y :x+y,[1,2,3,4], 5)
print a

15

copy例子：

import copy
a = [1, 2, 3, 4, ['a', 'b']]  #原始对象
b = a  #赋值，传对象的引用
c = copy.copy(a)  #对象拷贝，浅拷贝
d = copy.deepcopy(a)  #对象拷贝，深拷贝
a.append(5)  #修改对象a
a[4].append('c')  #修改对象a中的['a', 'b']数组对象
print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
# 对于嵌套的copy，只拷贝
输出结果：
a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
# 浅拷贝，只拷贝顶端(可变类型)
c =  [1, 2, 3, 4, ['a', 'b', 'c']]
# 深拷贝，拷贝原始内容，修改不会改变
d =  [1, 2, 3, 4, ['a', 'b']]