day10-总结

1.匿名函数

匿名函数就是没有函数名的函数(匿名函数可以看成类型是function的值和10,‘abc’是同类东西)

注意:匿名函数本质还是函数,函数中除了函数声明语法外其他的都使用匿名函数

1)语法:

函数名 = lambda 参数列表:返回值

2)说明

lambda - 关键字
参数列表 - 参数名1,参数名2,...(不用括号括起来)
:- 固定写法后面不产生缩进
返回值 - 任何有结果的表达式 ; 它是匿名函数的函数体,相当于普通函数的return语句

3)调用匿名函数:保存匿名函数值的变量(实参列表)

4)参数

普通函数中除了用‘参数名:类型’的形式来制定参数类型意外,其它的语法匿名函数都支持

sum1 = lambda x, y = 1: x + y
print_x = lambda x: x

print(sum1(1, 2))
print(print_x('dss'))

1.变量的作用域(变量在程序中能够使用的范围)

2.全局变量和局部变量

1)全局变量:没有声明在函数或者类里面的变量就是全局变量

作用域是从声明开始到文件结束的任何位置

2)局部变量:声明在函数中的变量就是局部变量(函数的参数相当于声明在函数中的变量)

作用域是从声明开始到函数结束的任何位置

3)函数调用过程(内存变化):压栈

当调用函数的时候,系统会自动在内存的栈区间为函数开辟一个独立的内存区域,
用来保存在函数中声明的变量。当函数调用结束这个内存区域会自动释放。

a = 10  # 全局变量

for x in range(5):  # x  - 全局变量
    pass

4)global 和 nonlocal

是函数中的关键字,和return一样只能在函数体中用

1)global - 在函数中声明一个全局变量

global 变量
变量 = 值

a = 111  # 全局变量

def fun3():
    # 声明一个局部变量
    a = 222
    global b  # global b变为全局变量 (如果函数外面有b则会修改函数外b的值)
    b = 333
    print('in', a, b)

fun3()
print('out', a, b)

2) nonlocal :在局部的局部去修改局部变量的值

nonlocal 变量
变量 = 值

a2 = 50

def f4():

    a2 = 100
    b2 = 100

    def f41():
        a2 = 500
        nonlocal b2
        b2 = 500
        print('第二层函数里面:', a2, b2)
    f41()
    print('第一层函数', a2, b2)

f4()
# print(a2)    # NameError: name 'a2' is not defined

1.递归函数

自己调用自己的函数(函数体中调用当前函数)
循环能做的事情,递归都能做

# def f1():
#     print('sssssssss')
#     f1()
# f1()  # RecursionError: maximum recursion depth exceeded while calling a Python object

2.怎么写递归

第一步:找临界值(调用递归函数(循环)结束的条件)
第二步:找关系 - 找f(n) 和 f(n-1)的关系(找当次循环和上次循环的关系)
第三步:假设函数的功能已经实现,根据关系用f(n-1)去实现f(n)的功能

注意:能用循环解决的问题就不要用递归(消耗内存和cpu过多)

# 递归函数:1 + 2 + 3 + ...+ n
def sum1(n):
    # 临界值 1
    if n == 1:
        return 1
    return n + sum1(n - 1)

print(sum1(100))
# 斐波那契序列
# 1, 1, 2, 3, 5,8, 13
# 递归函数求斐波那契序列的第n个数
def sequ(n):
    if n == 1 or n == 2:
        return 1
    return sequ(n - 2) + sequ(n - 1)

print(sequ(6))
# 练习:用递归实现向下的直角三角形

def poto(n):
    if n == 1:
        return '*'
    else:
        print(n * "*")
        return poto(n-1)

print(poto(9))

1.迭代器(iter)

迭代器作为容器可以保存多个数据;数据的来源:1)将其它序列转换成迭代器,2)生成器产生

1)将其它序列转换成迭代器

iter1 = iter('abc')
print(iter1, type(iter1))   #  
iter2 = iter([12, 30, 90])
print(type(iter2))  # 

2.获取元素

不管用那种方式去获取了元素的值,那么这个元素在迭代器中就不存在了

1)获取单个元素:

next(迭代器)、迭代器.next() ->获取迭代器中第一个元素

当取完所有迭代器中的数据之后再用next(迭代器)或迭代器.next()去获取元素会报错 # StopIteration

2)遍历
iter3 = iter('hello')
print(next(iter3))   # h
print(next(iter3))   # e
print(iter3.__next__())  # l

iter3 = iter('hello')

print(next(iter3))
for i in iter3:
    print('for;', i)

1.什么是生成器

1)生成器就是迭代器的一种

2)调用一个带有yield关键字的函数就可以得到一个生成器

(如果一个函数中有yield关键字:a.调用函数不会执行函数体;b.函数表达式的值不是函数的返回值)

1.创建生成器
def func1():
    yield
    print('=====')
    return 100
gen1 = func1()   # gen1就是一个生成器对象

print('外部', gen1)   # 外部 

for i in gen1:
    print(i)
2.生成器产生数据的原理
1)一个生成器能够产生多少数据,就看执行完生成器对应的函数的函数体会遇到几次yield,yield后面的值就是生成器能够产生的数据
2)每次获取生成器中的元素的时候,都是先去执行函数体,直到遇到yield,并且将yield后面的值作为获取元素的结果;并且保留结束的位置,下次获取下一个值的时候,从上一次结束的位置接着执行函数体,直到遇到yield...

如果从开始执行函数到函数结束都没有遇到yield就会报错(StopIteration)

def func1():
    print('++++++')
    yield 1
    print('----------')
    yield 100      # yield 后面可以跟数据且同一个函数可以有多个yild

gen2 = func1()
print(gen2)     # 

print(next(gen2))
# ++++++
# 1
print(next(gen2))
# ----------
# 100
# print(next(gen2))  # StopIteration
# 练习:
def f2():
    for i in range(0, 100, 3):
        yield i
print(next(f2()))
print(next(f2()))
print(next(f2()))
gen1 = f2()
print(next(gen1))
print(next(gen1))
print(next(gen1))

你可能感兴趣的:(day10-总结)