欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

函数的第一类对象,f格式化,迭代器以及递归

程序员文章站 2022-03-20 17:20:33
函数名的第一类对象及使用,f格式化以及迭代器 1.函数的第一类对象 2.f字符串格式化 3.迭代器 4.递归 ......

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

1.函数的第一类对象

第一类对象 --特殊点

1.可以当作值被赋值给变量

def func():
    print(1)
a = func
a()

2.可以当作元素存放在容器中

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


3.函数名可以当作函数的参数

def func(f):
    f()
def foo():
    print(1)
func(foo)


4.函数名可以当作函数的返回值
def func():
    def foo():
        print(1)
    return foo
a = func()
a()



def f(1):
    def f2():
        print(1)
        def f3():
            print(2)
        return f2
    ret = f2()
    return ret
print(f1())

2.f字符串格式化

# python3.6版本及以上才能够使用

s = f"你好('hello')"                 # 填充字符串
s1 = f"你好('hello')"

s1 = f"你好{s}"                     # 填充变量
print(s1)

s1 = f"{35+15}"                    #填充计算公式
print(s1)

a = 10                            #填充表达式
b = 20
s1 = f"(a if a>b else b)"
print(s1)

s1 = f"{{{{{{'你好..'}}}}}}"        #填充大括号
print(s1)

s1 = f"{{}}"
print(s1)

s1 = f"{'{}{}{}'}"
print(s1)

s1 = f"{print(123)}"
print(s1)

def prin(a):
    print(a)
s1 = f"{prin(123)}"
prin(s1)

def foo():
    def func():
        a = 1
        return a
    return func()

s1 = f"{foo()}"
print(s1)

lst = [1,2,3,4,5]
s1 = f"{lst[0:5]}"
print(s1)

dic = {'key1':123,'key2':456}
s1 = f"{dic['key2']}"
print(s1)

3.迭代器

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

验证是否为可迭代对象:
方式一:
    list.__iter__()
    dict.__iter__()
方式二:
    查看源码
方式三:
    print(dir(list))
    
官方声明:只要具有__iter__()方法的就是可迭代对象
    
可迭代对象的优点:
    1.使用灵活
    2.直接查看值
可迭代对象的缺点:
    1.消耗内存
    
取值方式:
    list,tuple,str   --索引
    dict             --键
    set              --直接取值
   


迭代器:
官方声明只要具有__iter__()  和 __next__()就是迭代器
f = open("t1.txt","r")
f.__iter__()
f.__next__()

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

new_lst.__iter__()
new_lst.__next__()

s = "123456"
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 = "123456"               #更改for的本质
s = [1,2,3,4,5,6]
count = len(s)
new_s = s.__iter__()
while count:
    print(new_s.__next__())
    count -= 1
    
s = "123456"
new_s = s.__iter__()           # for的真实本质
while true:
    try:
        print(new_s.__next__())        
    except stopiteration:
        break
        
except exception:
    print("万能审查")
    break
    
    
总结:
    可迭代对象:
        优点:使用灵活,可以直接查看值
        缺点:占内存,不能迭代取值
    迭代器:
        优点:节省内存,惰性机制
        缺点:使用不灵活,操作比较繁琐,不能直接查看元素
            
            
迭代器的特性:
    1.一次性的(永远就没有了)
    2.不能逆行(不能后退)
    3.惰性机制(节省内存)
 
什么是可迭代对象:
    具有很多私有方法,具有__iter__()方法的就是一个可迭代对象
什么是迭代器:
    具有__iter__()和__next__()方法的就是迭代器
    
迭代器什么时候使用:当容器中数据量较多的时候使用迭代器

4.递归

递归:
    1.自己调用自己(不断调用自己本身)    --死递归
    2.有明确的终止条件
    #满足两个以上的才是有效递归
递:一直执行直到碰到结束条件
归:从结束条件开始往回退
    
def func():
    print(123)
    func()
func()   
# 官方声明:最大层次1000,实际测试997/998

def age(n):
    if n == 4:
        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.宝元 18-2-2-2
2.太白 18-2-2
3.wusir 18-2
4.alex 18

def age(n):
    if n == 4:
        return 18
    else:
        return age(n+1)-2
print(age(1))


##过程
def age4(n):
    if n == 4:
        return 18
def age3(n):
    if n == 4:
        return 18
    else:
        return age4(n+1)-2
def age2(n):
    if n == 4:
        return 18
    else:
        return age3(n+1)-2
def age1(n):
    if n == 4:
        return 18
    else:
        return age2(n+1)-2
print(age1(1))