函数名的第一类对象及使用 f格式化 迭代器 递归

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

函数名可以当做值被赋值

def func():
    print(1)
print(func)
a = func
a()                   # <function func at 0x000001A24F8E9B70>     1

函数名可以当做元素存放在容器中

def func():
    print(1)
lst = [func,func,func]
for i in lst:
    i()                 # 1 1 1

函数名可以当做另一个函数的参数

def func(f):
    f()
def foo():
    print(123)
func(foo)                         # 123

函数名可以当做返回值

def func():
    def foo():
        print(123)
    return foo
a = func()
a()                                # 123

2.f格式化

f格式化的作用

填充字符串

s = f"你好{'常鑫'}"
s1 = F"{你好'常鑫'}"

填充变量

s = "常鑫"
S1 = f"你还是挺好的{s}"
print(s1)

填充计算公式

s1 = "{35+15}"
print(s1)

填充表达式

a = 10
b = 20
s1 = f"{a if a>b else b}"
print(s1)

填充大括号

s1 = f"{{{{{{'常鑫'}}}}}}"
print(s1)            # {{{'常鑫'}}}

3.迭代器

迭代器,一种工具

可迭代对象:

list,dict,str,set,tuple -- 可迭代对象 使用灵活

查看是否可迭代

方式一:

list.__iter__()

方式二:

查看源码

方式三:

print(dir(list))

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

优缺点

1.优点

​ 1.1 使用灵活

​ 1.2 直接查看值

2.缺点

​ 2.1 消耗内存

迭代器

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

句柄"f"是个迭代器
f = open("xxxx","w")
f.__iter__()
f.__next__()

lst = [1,2,3,4,6]
new_list = lst.__iter__()  #将可迭代对象转换成迭代器
new_list.__iter__()
new_list.__next__()

s = "123434"
new_s = s.__iter__()       #将可迭代对象转换成迭代器
print(new_s)
new_s.__iter__()
new_s.__next__()

new_s = s.__iter__()       #将可迭代对象转换成迭代器
print(new_s)
new_s.__iter__()
print(new_s.__next__())
print(new_s.__next__())
print(new_s.__next__())

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

s = "12345"
new_s = s.__iter__()
while True:
    try:
        print(new_s.__next__())   # for真实本质
    except StopIteration:
        break
        
# except Exception:
#     print("我是万能的!")
#     break

4.递归

定义

1.自己调用自己 (不断调用自己本身) -- 死递归

2.有明确的终止条件

满足以上两个才是有效递归

递:一直执行直到碰到结束条件

归:从结束条件开始往回退

官方声明: 最大层次1000,实际测试 998/997

示例:      猜3
def age(n): # 1,2,3
    if n == 3:
        return "猜对了"
    else:
        return age(n+1)
print(age(1))

分解

def age2(n):
    if n == 3:
        return "猜对了"

def age1(n):
    if n == 3:
        return "猜对了"
    else:
        age2(n+1)

def age(n):
    if n == 3:
        return "猜对了"
    else:
        age1(n+1)
age(1)

总结

可迭代对象:
优点:使用灵活,可以直接查看值
缺点:占内存,不能迭代取值

迭代器:
优点:节省内存,惰性机制
缺点:使用不灵活,操作比较繁琐,不能直接查看元素

迭代器的特性:
1.一次性的(用完就没有了)
2.不能逆行(不能后退)
3.惰性机制(节省内存)

什么是可迭代对象:
具有很多私有方法,具有__iter__()方法的就是一个可迭代对象

什么是迭代器:
具有__iter__()和__next__()方法的就是迭代器

迭代器什么时候使用:当容器中数据量较多的时候使用迭代器