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

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

目录

• Python函数03/函数名的第一类对象及使用/f 格式化/迭代器/递归
  • 内容纲要
  • 1.函数名的第一类对象及使用
  • 2.f 格式化
  • 3.迭代器
  • 4.递归
  • 5.今日总结
  • 6.今日练习

内容纲要

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

2.f格式化

3.迭代器

4.递归

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

第一类对象的的特殊点:
1.可以当做值赋值给变量
# def func():
#     print(1)
# # print(func)
# 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("is foo")
#
# func(foo)
4.函数名可以当做返回值
# def f1():
#     def f2():
#         print(1)
#         def f3():
#             print(2)
#         return f2
#     ret = f2()  # f2 函数的内存地址
#     return ret  #
# print(f1())

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

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

2.f 格式化

python3.6版本及以上才能够使用
# s = f"你好{'常鑫'}"       # 填充字符串
# s1 = F"你好{'常鑫'}"

# 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,3,4,5,6]
# s1 = f"{lst[0:5]}"
# print(s1)  # [1,3,4,5,6]

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

字符串格式化的三种方法:
# %s,format,f

3.迭代器

迭代 器(工具)
可迭代对象:
# list,dict,str,set,tuple -- 可迭代对象  使用灵活

方式一:
# list.__iter__()
# dict.__iter__()
# str.__iter__()
# set.__iter__()
# tuple.__iter__()

# 方法二:
# 查看源码

# 方法三:
# print(dir(list))

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

可迭代对象的优点:
    1.使用灵活
    2.直接查看值
可跌代对象的缺点:
    1.消耗内存
    
# list,tuple,str -- 索引
# dict -- 键
# set  -- 直接取值

迭代器:
官方声明只要具有__iter__()方法__next__()方法就是迭代器
# 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

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

总结:
#     可迭代对象:
#         优点:使用灵活,可以直接查看值
#         缺点:占内存,不能迭代取值
#
#     迭代器:
#         优点:节省内存,惰性机制
#         缺点:使用不灵活,操作比较繁琐,不能直接查看元素

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

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

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

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

4.递归

递归:
1.自己调用自己(不断调用自己本身)---死递归
2.有明确的终止条件
满足以上两个才是有效递归

递:一直执行直到碰到结束条件
归:从结束条件开始往回退
    
官方声明:最大层次1000,实际测试:998/997
        
# def func():
#     print(123)
#     func()
# func()

# def age(n): # 1,2,3
#     if n == 3:
#         return "猜对了"
#     else:
#         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))

#(自己学习的方法, -- 学会百度[学会自学] -- 先同学讨论)        

5.今日总结

# 1.函数名的第一类对象及使用
#     1.1 函数名可以当做值被赋值
#     1.2 函数名可以改当做元素存放在容器中
#     1.3 函数名可以当做另一个函数的参数
#     1.4 函数名可以当做返回值

# 2.f格式化
#     支持:F,表达式,函数调用,数字计算,列表取值,字典取值

# 3.迭代器
#     可迭代对象:
#         优点:使用灵活,可以直接查看值
#         缺点:占内存,不能迭代取值
#
#     迭代器:
#         优点:节省内存,惰性机制
#         缺点:使用不灵活,操作比较繁琐,不能直接查看元素

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

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

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

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

# 4.递归
    # 1.不断调用自己本身
    # 2.有明确的结束条件
    # 一递  一归

6.今日练习

# 1.请写出下列代码的执行结果：
# 例一：
# def func1():
#     print('in func1')
# def func2():
#     print('in func2')
# ret = func1
# ret()
# ret1 = func2
# ret1()
# ret2 = ret
# ret3 = ret2
# ret2()
# ret3()
# 执行结果：
# in func1
# in func2
# in func1
# in func1
#
# 例二：
# def func1():
#     print('in func1')
# def func2():
#     print('in func2')
# def func3(x, y):
#     x()
#     print('in func3')
#     y()
# print(111)
# func3(func2, func1)
# print(222)
# 执行结果：
# 111
# in func2
# in func3
# in func1
# 222
#
# 例三（选做题）：
# def func1():
#     print('in func1')
# def func2(x):
#     print('in func2')
#     return x
# def func3(y):
#     print('in func3')
#     return y
# ret = func2(func1)
# ret()
# ret2 = func3(func2)
# ret3 = ret2(func1)
# ret3()
# 执行结果：
# in func2
# in func1
# in func3
# in func2
# in func1
#
# 看代码写结果：
# 例四:
# def func(arg):
#     return arg.replace('苍老师', '***')
# def run():
#     msg = "Alex的女朋友苍老师和大家都是好朋友"
#     result = func(msg)
#     print(result)
# run()
# data = run()
# print(data)
# 看代码写结果：
# Alex的女朋友***和大家都是好朋友
# Alex的女朋友***和大家都是好朋友
# None
#
# 例五:
# data_list = []
# def func(arg):
#     return data_list.insert(0, arg)
# data = func('绕不死你')
# print(data)
# print(data_list)
# 看代码写结果：
# None
# ['绕不死你']
#
# 例六:
# def func():
#     print('你好呀')
#     return '好你妹呀'
# func_list = [func, func, func]
# for item in func_list:
#     val = item()
#     print(val)
# 看代码写结果：
# 你好呀
# '好你妹呀'
# 你好呀
# '好你妹呀'
# 你好呀
# '好你妹呀'
#
# 例七:
# def func():
#     print('你好呀')
#     return '好你妹呀'
# func_list = [func, func, func]
# for i in range(len(func_list)):
#     val = func_list[i]()
#     print(val)
# 看代码写结果：
# 你好呀
# '好你妹呀'
# 你好呀
# '好你妹呀'
# 你好呀
# '好你妹呀'
#
# 例八:
# def func():
#     return '大烧饼'
# def bar():
#     return '吃煎饼'
# def base(a1, a2):
#     return a1() + a2()
# result = base(func, bar)
# print(result)
# 看代码写结果：
# 大烧饼吃煎饼
#
# 例九:
# for item in range(10):
#     print(item)
# print(item)
# 看代码写结果：
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 9
#
# 例十:
# def func():
#     for item in range(10):
#         pass
#     print(item)
# func()
# 看代码写结果：
# 9
#
# 例十一:
# item = '老男孩'
# def func():
#     item = 'alex'
#     def inner():
#         print(item)
#     for item in range(10):
#         pass
#     inner()
# func()
# 看代码写结果：
# 9
![](https://img2018.cnblogs.com/blog/1730001/201907/1730001-20190719141311176-1984719003.png)
#
# 例十二:
# l1 = []
# def func(args):
#     l1.append(args)
#     return l1
# print(func(1))
# print(func(2))
# print(func(3))
# 看代码写结果：
# [1]
# [1,2]
# [1,2,3]
#
# 例十三:
# name = '宝元'
# def func():
#     global name
#     name = '男神'
# print(name)
# func()
# print(name)
# 看代码写结果：
# 宝元
# 男神
#
# 例十四:
# name = '宝元'
# def func():
#     print(name)
# func()
# 宝元
#
# 例十五:
# name = '宝元'
# def func():
#     print(name)
#     name = 'alex'
# func()
# 看代码写结果：
# 报错
# 开辟def func():这块空间的时候,会先检查一下def func():里边有没有语法错误,
# 里边有语法错误就会报错,但是并不会去执行def func():空间里边的内容.
# 第一次检查的时候,看到里边有一个name = 'alex',但是print(name)并没有找到
#
# 例十六:
# def func():
#     count = 1
#     def inner():
#         nonlocal count
#         count += 1
#         print(count)
#     print(count)
#     inner()
#     print(count)
# func()
# 看代码写结果：
# 1
# 2
# 2
#
# 例十七:
# def extendList(val, list=[]):
#     list.append(val)
#     return list
# list1 = extendList(10)
# list2 = extendList(123, [])
# list3 = extendList('a')
# print('list1=%s' % list1)
# print('list2=%s' % list2)
# print('list3=%s' % list3)
# 看代码写结果：
# list1=[10, 'a']
# list2=[123]
# list3=[10, 'a']
#
# 例十八:
# def extendList(val, list=[]):
#     list.append(val)
#     return list
# print('list1=%s' % extendList(10))
# print('list2=%s' % extendList(123, []))
# print('list3=%s' % extendList('a'))
# [10]
# [123]
# [10,'a']
#
# 2.用你的理解解释一下什么是可迭代对象，什么是迭代器。
# 可迭代对象:有__iter__()方法的就是可迭代对象
# 迭代器:有__iter__()方法和__next__()方法的就是迭代器
#
# 3.使用while循环实现for循环的本质(面试题)
# for循环的本质:
# s = "abcdefg"
# new_s = s.__iter__()
# while True:
#     try:
#         print(new_s.__next__())
#     except StopIteration:
#         break