函數名的第一類對象及使用,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))