一、函数

1、参数

def func(形参, *args, 关键字参, **kwargs)    pass

2、作用域

global：声明一个变量是全局变量。

nonlocal：声明一个变量是局部变量，用在函数嵌套中，内层函数用来声明一个变量是局部中离它最近的同名局部变量。如果声明的这个变量在局部中没有则报错，或者声明的这个变量在局部已经被声明为全局变量也报错。

3、命名空间

命名空间就是变量名和值的对应关系，分为内置、全局和局部，变量会分别保存在这三个地方。

函数里的变量只有在函数被执行时才会开辟命名空间，当函数执行完毕后又被清除，外部无法调用。

4、闭包

定义：在内层函数使用外层函数的变量

作用：1、保护变量不被全局中其他的函数改变。如果直接一层函数，并且使用全局变量，那这个变量很可能被其他函数修改，导致需要的变量值不对。2、常驻内存，使得局部的变量不被清除，为装饰器做铺垫。

def func1():a = 111def func2():return areturn func2func = func1()
f = func()
print(f)

举个例子

5、匿名函数

匿名函数一般搭配内置函数一起使用。

lambda x:x+1 

6、内置函数

(1) sorted

sorted用来给可迭代对象排序，有三个参数：iterable可迭代对象、key排序规则、reverse是否倒序。

sorted是创建列表将排序好的数据都放到新的列表，原数据并不改变，而列表的.sort()方法是修改原列表。

sorted不管传入的是什么数据类型，返回的都是列表，如果传入的是一个字符串，会将每个字符排序放入列表，如果传入的是一个字典，会将字典的键排序。

l = ["aaaaa", "aaa", "a", "aaas"]
print(sorted(l, key=lambda x:x.count("a"), reverse=False))  # 将列表按照含a的个数从小到大排序

d = [{"name": "小黑", "age": 3}, {"name": "小红", "age": 2}, {"name": "小明", "age": 1}]
print(sorted(d, key=lambda x:x["age"]))

(2) filter

filter用来对可迭代对象做过滤，有两个参数：function 规则、iterable 可迭代对象。

按照规则如果返回真则保留，返回假就不要。最后返回的是一个迭代器，需要用list()转换成列表。

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(filter(lambda x: x % 2 == 0, l)))  # 得到一个只有偶数的列表

(3) map

map对每个数据做一些操作，需要两个参数：func 规则、iterable可迭代对象。

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(map(lambda x: x + 1, l)))  #得到一个每个数都加1的列表

(4) zip

zip把传入的一个或多个可迭代对象中，索引值相同的元素打包成一个元祖，最后返回一个迭代器。

l1 = [1, 2, 3]
l2 = [3, 2, 1]
print(list(zip(l1, l2)))
>>>[(1, 3), (2, 2), (3, 1)]

(5) isinstance 和 issubclass

isinstance(obj, cls) 判断对象是否属于某个类型，包含继承关系。

issubclass(son, father) 判断一个类是否是一个类的子类。

二、装饰器

装饰器就是在不改变函数代码的前提下给函数添加新的功能。

1、装饰器的基本格式

def wrapper(func):def inner(*args,**kwargs):print("111")ret = func(*args,**kwargs)print("222")return retreturn inner@wrapper
def test():a = 1return a

2、装饰器的wraps

实际上@wrapper就是执行了test = wrapper(test)，使得我们调用的test函数变成了wrapper函数，导致函数的信息也变成了wrapper的，比如函数的名字，给装饰器内层的函数添加一个@wraper可以让函数的信息维持原来的样子。

from functools import wraperdef wrapper(func):@wraperdef inner(*args,**kwargs):print("111")ret = func(*args,**kwargs)print("222")return retreturn inner@wrapper
def test():a = 1return a

3、带参数的装饰器

def outer(a):def wrapper(func):def inner(*args,**kwargs):xxxxxreturn return innerreturn wrapper@outer(xx)

4、多个装饰器装饰一个函数

@wrapper1

@wrapper2

def xxxxx

这样会先执行1里func前的代码，再执行2中func前的代码，再执行func，再执行2中func后的代码，在执行1func后的代码。

三、迭代器

迭代器可以让不同的数据类型有相同的遍历方式。

只要含有__iter__方法的都是可迭代对象——可迭代协议

只要含有__next__和__iter__方法就是迭代器——迭代器协议

for循环就是在使用迭代器，举例：

for i in li:

当使用for循环时，就是在执行iterator = l.__iter__()，拿到的i就是通过iterator.__next__()获取到的。

四、生成器

定义：只要有yield关键字的函数，就是生成器函数。

生成器本质是迭代器，是迭代器的一种。

生成器函数在调用时不执行内部语句，只有在.__next__方法时，才执行到第一个yield为止，在下一次执行__next__方法时，执行到第二个yield。

注意，生成器里的值只能取一次。

特点：1、省内存，存的是代码，不是数据。2、惰性机制。3、只能向前，不能反复。

def func():yield 1yield 2yield 3yield 4>>> temp = func()
>>> temp.__next__()
1
>>> temp.__next__()
2
>>> temp.__next__()
3
>>> temp.__next__()
4
>>> temp.__next__()
Traceback (most recent call last):File "<stdin>", line 1, in <module>
StopIteration

生成器示例

一、创建生成器的两种方式：

def func():print(111)yield "111"print(func().__next__)

1、生成器函数

g = (i for i in range(10))

2、生成器表达式

二、next和send

# 生成器可以通过__next__方法取值
def func():yield 1yield 2yield 3g = func()
print(g.__next__())
print(g.__next__())
print(g.__next__())

next

# 生成器还可以通过send取值，并且send可以给上一个yield赋值
# 因为send是给上一个yield赋值，所以第一次只能用__next__
def func():print("开始")a = yiled "1"print("a:",a)b = yiled "2"print("b:",b)c = yiled "3"print("c:",c)yiled "结束"g = func()
print(g.__next__())  # 开始  1
pritn(g.send("这是a"))  # a:这是a  2
pritn(g.send("这是b"))  # b:这是b  3
pritn(g.send("这是c"))  # c:这是c  结束

send

三、惰性机制

生成器的惰性机制让生成器只有在取值的时候才会执行，否则生成器中保存的只是代码，没有数据。

def add(a,b):return a + bdef gen():for i in range(4):yield ig = gen()for n in [2, 10]:g = add(n,i) for i in g    # 这里生成器g并没有取值，所以并不执行这段代码，只是把这段代码完整的代入下一次循环，n没有机会等于2，只会等于10print(list(g))
# 这里g被取值了，实际上现在等于执行的是 [add(n, i) for i in (add(n,i) for i in g)]，这时的n都是10

四、各种推导式

[i for i in range(10)]  # 列表推导式
{i:i+1 for i in range(10)}  # 字典推导式
{i for i in range(10)}  # 集合推导式

用生成器自定义一个range函数：

def nrange(num):n = 0while n < num:yield nn += 1returnfor i in nrange(10):print(i)#得到 0,1,2,3,4,5,6,7,8,9

View Code