python 第十一章 函数名+格式化+迭代器+递归

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

# 第一类对象 -- 特殊点
# 没有调用得到：内存地址
#
# 1、可以当作值被赋值给变量
def func():
    print(1)
a = func
a()
# 输出 1

# 2、当做元素存放在容器中
def fun1():
    print("a")
def fun2():
    print("b")
lst = [fun1,fun2]
for i in lst:
    i()
# 输出
# a
# b



# 3、函数名可以当做函数的参数
def fun3():
    print("a")
def fun3_1(fn):
    print("b")
    fn()
    print("c")
fun3_1(fun3)
# 输出
# b
# a
# c



# 4、函数名可以当做函数的返回值
def fun4():
    print("a")
    def fun4_1():
        print("b")
    print("c")
    return fun4_1
fn = fun4()
fn()
# 输出
# a
# c
# b

格式化

# python3.6版本以及以上才能够使用,f和F都可以
# f"{}" {任意数据数据}
s =f"{1}"
print(s)

# 填充字符串
s =f"{'您好'}"
print(s)

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

# 填充各种计算公式
s =f"{1+2}"
print(s)

# 三元运算符
a = 10
b = 20
s2 =f"{a if a>b else b}"
print(s2)

# 两个{{ }}取一个{ }
s3 =f"{{{{hh}}}}"

# %s和format和f都能格式化，一样的操作

迭代器

# 迭代  器：工具
#
# 可迭代对象：
# list dict str set tuple
# 官方声明具有__iter__()方法的就是可迭代对象
# 查看可迭代对象
# 1、可点出来的方法都是可迭代对象
#.__iter__()
list.__iter__()
dict.__iter__()
str.__iter__()
set.__iter__()
tuple.__iter__()

#2、查看源码 command+鼠标移动到方式上

#3、dir()
print(dir(list))
s1 = "alex"
print(dir(s1))
i = 100
print(dir(i))
ls = [1,2,3]
print('_iter_' in dir(i))
print('_iter_' in dir(ls))



# 可迭代对象的优点：
# 1、使用灵活
# 2、直接查看值
#
# 可迭代对象的缺点：
# 1、消耗内存
# 2、不能迭代取值

# 可迭代对象的取值方式
# list,tuple,str -- 索引
# dict -- 键
# set -- 直接取值

# 迭代器：
# 官方声明只要具有__iter__方法__next__方法的就是迭代器
# 迭代器：
# 文件操作
f = open("文件名","r")
f.__iter__()
f.__next__()

# 将迭代对象转换成迭代器
# 迭代对象.__iter__，重新定义变量名，变成迭代器
# 再执行.__next__，一个一个取值
#
# 迭代器的优点：
# 1、节省内存
# 2、惰性机制
#
# 迭代器的缺点：
# 1、使用不灵活
# 2、操作比较繁琐
# 3、不能直接查看元素
#
# 迭代器的特性：
# 1、一次性的，用完销毁
# 2、不能逆行（不能后退）
# 3、惰性机制（节省内存）

# 将可迭代对象转成迭代器
s = () #任意可迭代对象
new_s = s.__iter__()
print(new_s)
# 将迭代器的元素一一输出
print(new_s.__next__())
print(new_s.__next__())

lst = [1,2,3,4,6]
new_list = lst.__iter__()  # 将列表转成迭代器
print(new_list.__next__()) # 1
print(new_list.__next__()) # 2
print(new_list.__next__()) # 3
# 输出123 与print一一对应


s = "12345"
new_s = s.__iter__()    # 将字符串转成迭代器
print(new_s.__next__()) # 1
print(new_s.__next__()) # 2
# 输出12 与print一一对应



# 输出迭代器的元素的类型
s = "123"
new_s = s.__iter__()
print(new_s)

# for 更改版循环的本质
# 列表型
s = [1, 2, 3]
count = len(s)
new_s = s.__iter__()
while count:
    print(new_s.__next__())
    count -= 1

# 字符串型
s1 = "alex"
count = len(s1)
new_s1 = s1.__iter__()
while count:
    print(new_s1.__next__())
    count -= 1


# for 循环的真正原理
s2 = "alex"
new_s2 = s2.__iter__()
# 捕获异常
while True:
    try: # 监听
        print(new_s2.__next__())
    except StopIteration: # 捕获
        print("取超了")
        break
    except Exception: # except 可多个  Exception 万能异常
        print("我是万能的")
        break

递归

# 递归
# 1、不断调用自己本身--死递归
# 官方声明：最大层次1000，实际测试998／997
def func():
    print(123)
    func()
func()

# 2、有明确的终止条件
def age(n):
    if  n == 18:
        return "对"
    else:
        return "错"
print(age(10))

# 用递归输出每个人的年龄
# 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))

总结

# 语法分析
# 执行法分析
#
# 陷阱，默认参数可迭代会有坑
# 不可变的迭代对象没有坑
#
# 三大器：迭代器，生成器，装饰器

# 1、函数名的第一类对象及使用
# 可以作为值赋值给变量
# 可以作为容器中的元素
# 可以当作另一个函数的参数
# 可以作为返回值
#
# 2、f格式化：f"{}{}"
# 格式化方法：f，F，%s，format
# 支持：表达式，函数调用，数字计算，列表取值，字典取值
#
# 3、迭代器
# 可迭代对象：能够使用__iter__()方法
# 迭代器：能够使用__iter__()和__next__()方法
#
# 可迭代对象的特性：
# 优点：使用灵活，可直接查看值，每个可迭代对象都有私有的方法
# 缺点：占内存，不能迭代取值
#
# 迭代器：
# 优点：省空间，惰性机制
# 缺点：使用不灵活，不能直接查看值，不能直接查看元素，不能逆行
#
# 迭代器的使用：
# 当容器中数据量较多的时候使用
#
# 4、递归
# 不断调用自己本身
# 有明确的结束条件
# 拆开理解
# 一递一归