python基础加强笔记.md

简单说说Python中的垃圾回收

Python中的垃圾回收的主要策略：引用计数与分代回收
引用计算：
一旦对象的引用计数为0，该对象立即被回收，对象占用的内存空间将被释放。
import sys#使用工具查看对象被引用次数
sys.getrefcount(对象名)
分代回收：
Python根据内存中对象的存活时间划分为不同的集合，每个集合称为一个代，共3代
分别为年轻代（新加入的对象）（第0代）、中年代（经历0代回收仍然存活的对象）（第1代）,老年代（经历0代，1代回收仍然存活的对象）（第2代） 他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。
可以使用gc模块查看当前监视对象的个数，以及触发垃圾回收的阈值

Python中的垃圾回收

迭代器与生成器有什么相似与不同的地方？

iter()
iter() 函数用来生成迭代器。
iter(object)

Python官方文档对于这种形式的解释很容易理解。

此时，object必须是集合对象，且支持迭代协议（iteration protocol）或者支持序列协议（sequence protocol）。

说白了，也就是实现了__iter__()方法或者__getitem__()方法。

>>>lst = [1, 2, 3]
>>> for i in iter(lst):
... print(i)
... 
1
2
3

对Python语言中的名字(命名）空间的认识

名称到对象的映射的容身之处就是名称空间。名称空间是一个字典对象，键为名字（变量名，标识符），值是名字对应的对象。
各个命名空间是独立没有关系的，一个命名空间中不能有重名，但是不同的命名空间可以重名而没有任何影响

Python中共有四类名字空间：

内置命名空间（Built-in）：也叫Python自带电池，任何模块均可以访问，放着内置的函数和异常（比如：input，print，str，list，tuple…）。

全局命名空间（Global）：每个模块加载执行时创建的，记录在该模块中定义的变量，包括模块中定义的函数、类、其他导入的模块、模块级的变量与常量。

闭包（Closure）：当函数被函数所嵌套时，所引用的其外部函数使用域上的变量，即闭包。

局部命名空间（Local）：每个函数所拥有的命名空间，记录了函数中定义的所有变量，包括函数的入参、内部定义的局部变量。

闭包：

def make_adder(addend):
    def adder(augend):
        return augend + addend
    return adder

p = make_adder(23)
print(p)
q = make_adder(44)
print(q)

print(p(100))
print(q(100))

result:

分析:

我们发现,make_adder是一个函数,包括一个参数addend,比较特殊的地方是这个函数里面又定义了一个新函数,这个新函数里面的一个变量正好是外部make_adder的参数.
也就是说,外部传递过来的addend参数已经和adder函数绑定到一起了,形成了一个新函数,我们可以把addend看做新函数的一个配置信息,配置信息不同,函数的功能就不一样了,也就是能得到定制之后的函数.

再看看运行结果,我们发现,虽然p和q都是make_adder生成的,但是因为配置参数不同,后面再执行相同参数的函数后得到了不同的结果.这就是闭包.

def makebold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped

def makeitalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

print(hello())

result:
简单分析
怎么样?这个程序熟悉吗?这不是传说的的装饰器吗?
对,这就是装饰器,其实,装饰器就是一种闭包,

我们再回想一下装饰器的概念:对函数(参数,返回值等)进行加工处理,生成一个功能增强版的一个函数。再看看闭包的概念,这个增强版的函数不就是我们配置之后的函数吗?区别在于,装饰器的参数是一个函数或类,专门对类或函数进行加工处理。

python里面的好多高级功能，比如装饰器，生成器，列表推到，闭包，匿名函数等，开发中用一下，可能会达到事半功倍的效果！

参数,位置参数（定位参数）,关键字参数, 不定长位置参数与关键字参数

def myadd(a,b,c,d,*parms):
    print(type(parms))
    print('parms:',parms)
    print('a,b,c,d:',a,b,c,d)
    return sum(parms)

myadd(1,2,3,4,5,6)

由此可以看出，不定长位置参数是一个 元组tuple

#参数：位置参数（定位参数），与不定长位置参数
def myadd2(a,b):
    return a+b

def myadd3(a,b,c):
    return a+b+c

def myadd4(a,b,c,d):
    print(d)


def myadd(arg,*args):
    print(type(args))
    print(args)
    return sum(args)
myadd(18,1,2,3)
# myadd4(6,3,5,3)
# myadd4(3,4,5,5)

# myadd(1,3,7,7,7,7,7,7,7,7,5,7,7,7,7,77,8,2)

关键字参数，与不定长关键字参数
关键字参数：

#关键字参数，与不定长关键字参数
def myadd0(args,lastnum=1000):
    return args+lastnum

myadd0(7)

def myaddkw(**names)