Python基础+刷廖雪峰教程笔记(二)——迭代、生成器、高级函数、装饰器、偏函数

由于在深度学习的路上,发现自己两年前学习的python有些遗忘,在面向对象这一块尤其不熟悉,故刷一遍廖雪峰老师的官方教程,梳理一下遗漏的知识点。

参考网址:https://www.liaoxuefeng.com/wiki/1016959663602400

1.迭代

如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们称为迭代(Iteration)。

demo1:

#字典类型的迭代
d = {'a': 1, 'b': 2, 'c': 3}
#默认情况下,dict迭代的是key
for key in d:
    print(key)

print('-' *50)
#迭代value
for value in d.values():
    print(value)

print('-' *50)
#同时迭代key和value
for k, v in d.items():
    print(k, v)

out1:

a
b
c
--------------------------------------------------
1
2
3
--------------------------------------------------
a 1
b 2
c 3

判断对象是否可迭代:

通过collections.abc模块的Iterable类型判断

demo2:

from collections.abc import Iterable
res1 = isinstance('abc', Iterable) # str是否可迭代
print(res1)
res2 = isinstance([1,2,3], Iterable) # list是否可迭代
print(res2)
res3 = isinstance(123, Iterable) # 整数是否可迭代
print(res3)

out2:

True
True
False

2.enumerate函数

Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身。

demo3:

for i, value in enumerate(['A', 'B', 'C']):
     print(i, value)

out3:

0 A
1 B
2 C

3.列表生成式

在一个列表生成式中,for前面的if … else是表达式,而for后面的if是过滤条件,不能带else。

demo4:

L1 = [x for x in range(1, 11) if x % 2 == 0]
L2 = [x if x % 2 == 0 else -x for x in range(1, 11)]#for前面的部分是一个表达式,它必须根据x计算出一个结果
print(L1)
print(L2)

out4:

[2, 4, 6, 8, 10]
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]

4.生成器

所以,如果列表元素可以按照某种算法推算出来,那我们就可以在循环的过程中不断推算出后续的元素,这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。

要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator。

demo5:

L = [x * x for x in range(10)]
print(L)
g = (x * x for x in range(10))#将[]改成()
print(g)
print(next(g))#通过next()函数获得generator的下一个返回值,打印出来
print(next(g))
print(next(g))
print('-' * 50)
#使用for循环,因为generator也是可迭代对象
g = (x * x for x in range(10))
for n in g:
     print(n)

out5:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x000001FE92699308>
0
1
4
--------------------------------------------------
0
1
4
9
16
25
36
49
64
81

定义generator的另一种方法:如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generato。

generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。

demo6:

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

#调用该generator时,首先要生成一个generator对象
#然后用next()函数不断获得下一个返回值

o = odd()
print(next(o))
print(next(o))
print(next(o))
print(next(o))
    

out6:

step 1
1
step 2
3
step 3
5
Traceback (most recent call last):
  File "C:\Users\邓富元\Desktop\1.py", line 16, in <module>
    print(next(o))
StopIteration

odd不是普通函数,而是generator,在执行过程中,遇到yield就中断,下次又继续执行。执行3次yield后,已经没有yield可以执行了,所以,第4次调用next(o)就报错。

5.迭代器

可以直接作用于for循环的对象统称为可迭代对象:Iterable。

可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。

demo7:

#可以使用isinstance()判断一个对象是否是Iterable对象
from collections.abc import Iterable
print(isinstance([], Iterable))
print(isinstance('abc', Iterable))
print(isinstance(100, Iterable))
print('-' * 50)

#可以使用isinstance()判断一个对象是否是Iterator对象
from collections.abc import Iterator
print(isinstance((x for x in range(10)), Iterator))
print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abc', Iterator))

out7:

True
True
False
--------------------------------------------------
True
False
False
False

生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数.

demo8:

from collections.abc import Iterator
print(isinstance(iter([]), Iterator))
print(isinstance(iter('abc'), Iterator))

out8:

True
True

总结:

凡是可作用于for循环的对象都是Iterable类型;

凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;(列表[]换成()就变成生成器generator)

集合数据类型如list、dict、str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的。

6.高阶函数

既然变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

demo9:

def add(x, y, f):
    return f(x) + f(y)

print(add(-5, 6, abs))

out9:

11

7.map()和reduce()函数

map()函数。map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。

reduce()函数。reduce把一个函数作用在一个序列[x1, x2, x3, …]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

demo10:

from functools import reduce
def f(x):
    return x * x

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))#结果r是一个Iterator,Iterator是惰性序列,因此通过list()函数让它把整个序列都计算出来并返回一个list


def add(x, y):
    return x + y

res = reduce(add, [1, 3, 5, 7, 9])
print(res)

out10:

[1, 4, 9, 16, 25, 36, 49, 64, 81]
25

8.filter()函数

Python内建的filter()函数用于过滤序列。

和map()类似,filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。

注意:filter()函数返回的是一个Iterator,也就是一个惰性序列,所以要强迫filter()完成计算结果,需要用list()函数获得所有结果并返回list。

demo11:

#删掉偶数,只保留奇数
def is_odd(n):
    return n % 2 == 1

res = list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
print(res)

out11:

[1, 5, 9, 15]

9.函数作为返回值

不需要立刻求和,而是在后面的代码中,根据需要再计算,则可以不返回求和的结果,而是返回求和的函数。

demo12:

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

#调用lazy_sum()时,返回的并不是求和结果,而是求和函数
f = lazy_sum(1, 3, 5, 7, 9)
print(f)
#调用函数f时,才真正计算求和的结果
print(f())

out12:

<function lazy_sum.<locals>.sum at 0x0000023547416620>
25

在这个例子中,我们在函数lazy_sum中又定义了函数sum,并且,内部函数sum可以引用外部函数lazy_sum的参数和局部变量,当lazy_sum返回函数sum时,相关参数和变量都保存在返回的函数中,这种称为“闭包(Closure)”.

demo13:

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print(f1(), f2(), f3())

out13:

9,9,9

不是1, 4, 9而是9, 9, 9的原因就在于返回的函数引用了变量i,但它并非立刻执行。等到3个函数都返回时,它们所引用的变量i已经变成了3,因此最终结果为9。

返回闭包时牢记一点:返回函数不要引用任何循环变量,或者后续会发生变化的变量。

10.匿名函数

关键字lambda表示匿名函数,冒号前面的x表示函数参数。

匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果。

用匿名函数有个好处,因为函数没有名字,不必担心函数名冲突。此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数。

demo14:

#把匿名函数赋值给变量
f1 = lambda x: x * x
print(f1)
print(f1(5))

#把匿名函数作为返回值返回
def build(x, y):
    return lambda: x * x + y * y

f2 = build(2, 3)
print(f2())

out14:

<function <lambda> at 0x0000020EF6499158>
25
13

11.装饰器

函数对象有一个__name__属性,可以拿到函数的名字。
demo15:

def now():
    print('2015-3-25')

print(now.__name__)#前后各两个下划线

out15:

now

增强now()函数的功能,比如,在函数调用前后自动打印日志,但又不希望修改now()函数的定义,这种在代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)。

本质上,decorator就是一个返回函数的高阶函数。

demo16:

#定义一个能打印日志的decoretor
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

#因为它是一个decorator,所以接受一个函数作为参数,并返回一个函数
#借助Python的@语法,把decorator置于函数的定义处

@log
def now():
    print('2015-3-25')

now()#调用now()函数,不仅会运行now()函数本身,还会在运行now()函数前打印一行日志
#把@log放到now()函数的定义处,相当于执行了语句now = log(now)

out16:

call now():
2015-3-25

(装饰器部分不太懂,以后用到再具体看)

12.偏函数

Python的functools模块提供了很多有用的功能,其中一个就是偏函数(Partial function)。要注意,这里的偏函数和数学意义上的偏函数不一样。

在介绍函数参数的时候,我们讲到,通过设定参数的默认值,可以降低函数调用的难度。而偏函数也可以做到这一点。

functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),可以直接使用下面的代码创建一个新的函数int2。

demo17:

print(int('12345',base=8))#按八进制转换,即12345为8进制的数
print(int('12345',16))#按十六进制转换
print(int('1010',base=2))#按二进制转换

#创建一个偏函数
import functools
int2 = functools.partial(int, base=2)
print(int2('1000000'))
#也可以在函数调用时传入其他值
print(int2('1000000',base=10))

#创建偏函数时,实际上可以接收函数对象、*args和**kw这3个参数
max2 = functools.partial(max, 10)#把10作为*args的一部分自动加到左边

out17:

5349
74565
10
64
1000000
10

简单总结functools.partial的作用就是,把一个函数的某些参数给固定住(也就是设置默认值),返回一个新的函数,调用这个新函数会更简单。

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值