函数名的第一类对象及使用

目录

1. 第一类对象的特点

#1. 函数名可以当作值被赋值给变量
def func():
    print(1)
ret = func
print(ret)  #输出func函数的地址

#2. 函数名当作元素存放在容器中
def func():
    a=1
    print(a)
lst = [func,func,func]   #放入lst中
for i in lst:
    i()      # 1 1 1
    
#3. 函数名可以当作函数的参数
def func(f):
    print(1)
    f()
def foo():
    print(2)
func(foo)    #foo地址给f   1  2

#4. 函数名可以当作函数的返回值
def func():
    print(2)       
    def foo():
        print(5)     
    return foo
ret = func()  #foo 地址   2 5
ret()  #调用 foo函数    

2. 格式化

f"你好{'a'}"  #填充字符串
f"你好{'a'}"  # f
s = f"你好{s1}"  #填充变量
s = f"{35+15}"  #填充计算公式
s = f"{a if a > b else b}"  #填充表达式
s = f"{lst[0:2]}"  #填充列表和字典

3. 迭代器

3.1 可迭代对象

list、dic、str、set、tuple都是可迭代对象，使用灵活
#方法：
1. list__iter__()
2. ctrl 查看源码
3. print(dir(list))

官方声明：只要对象具有__iter__()方法的就是迭代对象

可迭代对象的优点:
    1.使用灵活
    2.直接查看值
可迭代对象的缺点:消耗内存

取值方式：
list,tuple,str -- 索引
dict -- 键
set  -- 直接取值

3.2 迭代器

#官方声明只要具有__iter__()方法__next__()方法就是迭代器

lst = [1,2,3,4,6]
new_lst = lst.__iter__()  #将可迭代对象转换成迭代器
print(new_lst.__next__()) #从上一个位置开始向下打印一个元素
#迭代器取值超出范围时，会报错

#迭代器特性：
    #1.一次性的(用完就没有了)
    #2.不能逆行(不能后退)
    #3.惰性机制(节省内存)
#迭代器什么时候用：当容器数据量较大时，使用迭代器

s = [1,2,3,4,5,7]    # 更改版 for循环
count = len(s)
new_s = s.__iter__()
while count:
    print(new_s.__next__())
    count -= 1

# while循环实现for循环的本质
s = "12345"
new_s = s.__iter__()
while true:
    try:                        #会处理错误
        print(new_s.__next__()) # for真实本质
    except stopiteration: #当出stopiteration错误时，关闭
        break
#或
    except exception:   #万能异常捕获错误
        break

4. 递归

1. 不断调用自己本身(自己调用自己)——死循环
   最大层次1000，实际测试997/998
2. 有明确的终止条件
满足以上两个才是有效递归。
递：一直执行直到碰到结束条件
归：从结束条件开始往回退

def age(n):
    if n == 3:
        return 30
    else:
        return age(n+1)-5
print(age(1))     # 20

#上面解开：
def age3(n):
    if n == 3:
        return 30
    # else:
    #     return age2(n+1)-5
def age2(n):
    if n == 3:
        return 30
    else:
        return age3(n+1)-5
def age1(n):
    if n == 3:
        return 30
    else:
        return age2(n+1)-5
print(age1(1))