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

day011_步入百万年薪的第十一天

程序员文章站 2022-06-09 21:24:48
day11 函数名的第一类对象及使用 1、可以当作值被赋值给变量 2、当作元素存放在容器中 3、函数名可以当作函数的参数 4、函数名可以当作函数的返回值 f格式化 python3.6版本以上才能使用 填充字符串 填充变量 填充计算公式 填充表达式 填充大括号(两个大括号算一个) 其他填充 %s,fo ......

day11

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

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(123)
func(foo)
---------------------
def func(f):
    f()
def foo():
    print('is foo')
func(foo)

4、函数名可以当作函数的返回值

def func():
    def foo():
        print(123)
    return foo
a = func()
a()
-----------------------------
def f1():
    def f2():
        print(1)
        def f3():
            print(2)
        return f2
    ret = f2()
    return ret
print(f1())

f格式化

python3.6版本以上才能使用

  • 填充字符串
s = f"你好{'常鑫'}"
s1 = f"你好{'常鑫'}"
  • 填充变量
s1 = f"你还是挺好的{s}"
print(s1)
  • 填充计算公式
s1 = f"{34+11}"
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(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":234}
s1 = f"{dic['key2']}"
print(s1)

%s,format,f都是格式化,都可实现效果。

迭代器

可迭代对象

list、dict,str,tuple,set——可迭代对象

方法一:

list.__iter__()
dict.__iter__()
str.__iter__()
set.__iter__()
tuple.__iter__()

方法二:

查看源码

方法三:

print(dir(list))

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

  • 可迭代对象的优点:

​ 1、使用灵活

​ 2、直接查看值

  • 可迭代对向的缺点:

​ 消耗内存,不能迭代取值

list,tuple,str —— 索引

dict ——键

set——直接取值

迭代器

官方声明只要具有______iter______()方法和______next______()方法就是迭代器

f = open("xxxx",'w')
f.__iter__()
f.__iter__()
  • 优点:节省内存,惰性机制

  • 缺点:使用不灵活,操作比较繁琐,不能直接查看全部的值

  • 迭代器的特性:

    ​ 1、一次性的(用完就没有了)

    ​ 2、不能逆行(不能后退)

    ​ 3、惰性机制(节省内存):要一个给一个,不要就不给

  • 当容器中数据量较大的时候使用迭代器

lst = [1,2,3,4,55]
new_list = lst.__iter__() # 将可迭代对象转换成迭代器
-----------------------------
new_list.__iter__()
new_list.__next__()
----------------------
s = '123455'
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__())

for循环

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

递归

有效递归:

  • 不断调用自己本身(自己调用自己)
  • 有明确的终止条件

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

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

官方声明:最大层次(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))