周末学习笔记——day02

2019-04-26 08:19:22来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

一,复习

'''
1.函数的参数:实参与形参
    形参:定义函数()中出现的参数
    实参:调用函数()中出现的参数
    形参拿到实参的值,如果整体赋值(自己改变存放值的地址),实参不会改变,(可变类型)如果修改内部内容,实参会跟着变化
    
    位置实参 - 只能对位置形参赋值
    关键字实参 - 可以对所有(不包含可变长位置形参)形参赋值
    
    位置形参 - 必须出现在最前,且必须传值
    默认形参 - 出现在位置形参后*前,可以不用传参
    可变长位置形参 - 接收所有位置形参、默认形参没有接收完的位置实参
    有无默认值关键字形参 - 必须出现在所有位置形参之后,有默认值可以不用传参,没有默认值必须通过关键字实参传值
    可变长关键字形参 - 接收所有有名字的关键字形参没有接收完的关键字实参
    
   def fn(a, b=10, *args, c, d=20, e, **kwargs): pass

    
2.函数的嵌套调用
    在一个函数的内部调用另一个函数:在函数内部遇到调用其他函数,就进入其他函数内部,全部走完 回到调用其他函数 的入口

3.函数对象
    - 直接赋值、可以加()调用、作为其他函数的参、作为函数的返回值、作为容器对象的元素(成员)
4.名称空间与作用域
    - LEGB:查找顺序LEGB | 加载顺序BGEL
    
5.函数的嵌套定义 - 闭包
    - 函数的嵌套定义:在一个函数内部定义另一个函数,内部的函数就是闭包
    - 应用场景:
        - 延迟执行
        - 装饰器

6.装饰器
'''

 

二,带参装饰器

# 为什么要出现带参装饰器
def outer(func):
    # outer与inner之间要使用外部数据
    # 可以解决的方案路径,给outer添加参数,但是outer的参数是固定一个,就是被装饰的函数
    def inner(*args, **kwargs):
        res = func(*args, **kwargs)
        return res
    return inner

# 所以只能使用函数的闭包,通过外层函数给内存函数传递参数的方式
def wrap(*arg, **kwargs):
    def outer(func):
        # 就可以使用wrap中的*arg, **kwargs,就是要使用的外部数据
        def inner(*args, **kwargs):
            res = func(*args, **kwargs)
            return res
        return inner
    return outer

a = 10
b = 20
@wrap(a, b)  # @wrap(10, 20) => @outer => fn = outer(fn) => fn = inner
def fn():
    pass

 

三,wraps修改函数文档注释

# 为什么要出现该语法

from functools import wraps
def outer(func):
    @wraps(func)
    def inner(*args, **kwargs):
        res = func(*args, **kwargs)
        return res
    return inner
def fn():
    '''
    fn的文档注释
    '''
   
print(fn.__doc__)  # fn本质是inner,使用打印fn.__doc__本质是inner函数的文档注释

# 形参假象:让打印fn.__doc__显示的效果是fn自己的

 

今日内容

'''
基础残留:三元表达式,列表字典推导式

迭代器:可迭代对象、迭代器对象、for循环迭代器、枚举对象、生成器(自定义的迭代器)

内置函数:匿名函数、常用的内置函数

模块:模块,包,常用模块
'''

 

三元表达式

# what:就是简写if...else...结构,且都只有一条语句
# 语法:结果1 if 条件 else 结果2
# 注意:结果1|2不一定要与条件有必然关系,条件只是选择结果1或结果2的判断依据

# 案例:获得两个数中的大值 | 小者
n1 = int(input('n1: '))
n2 = int(input('n2: '))
res = n1 if n1 > n2 else n2
print(res)
res = n2 if n1 > n2 else n1
print(res)

 

列表与字典的推导式

# 列表推导式
# 语法:[结果 for 结果 in 可for循环操作的对象]
# 案例:[v for v in 'abc'] => ['a', 'b', 'c']
# 案例:['奇数' if i % 2 != 0 else '偶数' for i in range(1, 11)]


# 字典推导式
# 语法:{k: v for k, v in 可for循环操作的对象(每一次循环的结果可以被解压为两个值)}

# 案例: [('a', 1), ('b', 2)] => {'a': 1, 'b': 2}
# dic = {k: v for k, v in [('a', 1), ('b', 2)]}

# 案例:{i: 0 for i in 'abc'} == {}.fromkeys('abc', 0) == {'a': 0, 'b': 0, 'c': 0}

 

迭代器

可迭代对象

# 有__iter__()方法的对象都称之为 可迭代对象

# 可迭代对象:可以被转化为不依赖索引取值的容器,这样的对象就叫做可迭代对象
#       -- 对象.__iter__() 来生成不依赖索引取值的容器
#       -- 结论:有__iter__()方法的对象都称之为 可迭代对象

# 可迭代对象.__iter__() => 和该对象有关系的迭代器对象 dict_keyiterator object
box = dic.__iter__()  

# 可迭代对象有哪些:str | list | tuple | set | dict | range() | enumerate() | file | 生成器对象

迭代器对象

# 有__next__()且可以通过__next__()进行取值的容器

# 迭代器对象:可以通过__next__()的方式进行取值的容器,且取一个少一个
#       -- 结论:有__next__()且可以通过__next__()进行取值的容器
#       -- 注意:迭代器对象自身也拥有__iter__(), 通过该方法返回的是迭代器对象自身

res = box.__next__()  # 从迭代器对象(容器)取出值,取一个少一个
box = box.__iter__()  # 迭代器对象.__iter__()得到迭代器对象本身

# 迭代器对象有哪些:enumerate() | file | 生成器对象

for迭代器

# 可以操作迭代器对象及可迭代对象,且能自动处理异常的循环,内部同迭代器对象__next__()来取值

# 迭代器(for循环):就是用来从可迭代对象中进行取值的循环方法 | 语法:for 变量 in 对象:
#       -- 1.通过对象.__iter__()获取其对应的迭代器对象
#           -- for可以操作迭代器对象及可迭代对象,统一写法,所以迭代器和可迭代对象都有__iter__()
#       -- 2.在内部通过迭代器对象的__next__()进行取值,将值赋值给 语法中的变量,取一个少一个
#       -- 3.当迭代器对象取完了,在内部自动捕获异常,并结束循环取值
ls = [1, 2, 3, 4, 5]
for v in ls:
    print(v)
for v in ls.__iter__():
    print(v)

 

生成器

# 自定义的迭代器对象,写法和函数非常相似,但是内部用yield来对外部返回值,且可以有多个yield
# 语法:
def my_generator():  # => [1, 2, 3]
    yield 1
    yield 2
    yield 3
# 生成器名() 不是函数的调用,而是得到生成器对象,生成器对象就是迭代器对象,所有有__next__()方法
obj = my_generator()

# 一个个取值
# 去生成器中执行代码,拿到遇到的第一个yield后面的值,并停止运行
print(obj.__next__())
# 再接着上一个yield,再进行往下执行代码,再拿到下一个个yield后面的值,并停止运行
print(obj.__next__())
# 重复上面的过程,如果没有遇到yield,就报错
print(obj.__next__())

# 循环取值
while True:
    try:
        print(obj.__next__())
    except Exception:
        break
        
        
# 案例:
# 将传入的值扩大两倍返回
def fn1(*args):
    i = 0
    while i < len(args):
        yield args[i] * 2
        i += 1

for v in fn1(10, 20, 30, 40, 50):
    print(v)
    

# 依次获取阶乘 1! 2! 3! ...
def fn2():
    total = 1
    count = 1
    while True:
        total *= count
        yield total
        count += 1
obj = fn2()
print(obj.__next__())  # 1!
print(obj.__next__())  # 2!
print(obj.__next__())  # 3!
# ...
# print(obj.__next__())  # n!

 

了了解:生成器的send

# send:
# 1.send会为当前停止的yield传入参数,内部可以通过yield来接收传入的参数
# 2.send自身也会调用__next__()去获取下一个yield的结果

def fn4(peoples):
    count = 0
    print('%s在面试' % peoples[count])
    while count < len(peoples):
        name = yield peoples[count]
        count += 1
        print(name + "叫来%s来面试" % peoples[count])

peoples = ['张三', '李四', '王五']
obj4 = fn4(peoples)
name = obj4.send(None)  # 第一次没有yield接收值,所以只能调__next__(),或是send(None)
print(name + '面试完毕')
while True:
    try:
        name = obj4.send(name)
        print(name + '面试完毕')
    except Exception:
        print('所有人面试完毕')
        break

 

枚举对象

# 枚举对象:为迭代器对象产生迭代索引

ls = [3, 1, 2, 5, 4]
list(enumerate(ls))  # => [(0, 3), (1, 1), (2, 2), (3, 5), (4, 4)]

dic = {'a': 100, 'b': 200}
print(list(enumerate(dic)))  # => [(0, 'a'), (1, 'b')]

 

递归

# 递归:函数直接或间接调用自己
# 回溯:找寻答案的过程
# 递推:通过最终的值反向一步步推出最初需要的结果

# 前提:
# 1.递归条件是有规律的
# 2.递归必须有出口


# 拿递归求得年纪
def get_age(num):
    if num == 1:
        return 58
    age = get_age(num - 1) - 2
    return age
age = get_age(10)
print(age)


# 传入一个num,求得该num的阶乘
# 5! = 5 * 4 * 3 * 2 * 1 = 5 * 4!
# 4! = 4 * 3 * 2 * 1 = 4 * 3!
# 3! = 3 * 2 * 1 = 3 * 2!
# 2! = 2 * 1 = 2 * 1!
# 1! = 1
def get_total(num):
    if num == 1 or num == 0:
        return 1
    total = num * get_total(num - 1)  # 3 * 2! => 2 * 1!1 => 1 => 2 * 1
    return total
print(get_total(3))

 

 

 


原文链接:https://www.cnblogs.com/HZLS/p/10770588.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:list学习内容总结

下一篇:day11