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

内容纲要

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

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

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

    函数名的第一类对象及使用,f格式化以及迭代器 1.函数的第一类对象 第一类对象 --特殊点 1.可以当作值被赋值给变量 def func(): print(1) a = func a() 2.可以当作 ...

  2. python27期day10：函数的动态参数、函数的注释、函数的名称空间、函数的嵌套、global（修改全局的）、nonlocal（修改局部的）、函数名的第一类对象及使用、作业题。

    1.动态参数的作用: 能够接收不固定长度参数 位置参数过多时可以使用动态参数 * args是程序员之间约定俗称(可以更换但是不建议更换) * args获取的是一个元组 ** kwargs获取的是一个字 ...

  3. 百万年薪python之路 -- 函数名的第一类对象及使用

    函数名是一个变量, 但它是一个特殊的变量, 与括号配合可以执行函数的变量 1.1.函数名的内存地址 def func(): print("呵呵") print(func) 结果: ...

  4. python学习 03 函数 （只会执行一次return就不会往下执行）

    1.调用函数只会执行一次return,而且执行return后不会往下执行

  5. day11函数的进阶动态参数，命名空间，作用域，第一类对象

    一.习题收藏 5.写函数,计算传入字符串中[数字].[字母].[空格] 以及 [其他]的个数,并返回结果. # def func4(s): # dic = { # 'num':0,'alpha':0, ...

  6. day11——函数名的使用、f格式化、迭代器、递归

    day11 函数名的第一类对象及使用 1.可以当作值被赋值给变量 def func(): print(1) print(func) a = func a() 2.当作元素存放在容器中 def func ...

  7. python之路--第一类对象,函数名,变量名

    一 . 第一类对象 函数对象可以像变量一样进行赋值 , 还可以作为列表的元素进行使用 可以作为返回值返回 , 可以作为参数进行传递 def func(): def people(): print('金 ...

  8. python 函数名的应用(第一类对象),闭包,迭代器

    1.函数名的应用(第一类对象) 函数名的命名规范和变量是一样的 函数名其实就是变量名 可以作为列表中的元素进行储存. def func1(): pass def func2(): pass lst = ...

  9. python基础(13):函数名的使用、第一类对象、闭包、迭代器

    1. 函数名的运用 函数名是⼀个变量,但它是⼀个特殊的变量,与括号配合可以执⾏函数的变量. 1.1 函数名的内存地址 def func(): print("呵呵") print(f ...

随机推荐

  1. @hdu - 6607@ Easy Math Problem

    目录 @description@ @solution@ @accepted code@ @details@ @description@ 求: \[\sum_{i=1}^{n}\sum_{j=1}^{n ...

  2. linux安装syncthing

    https://blog.csdn.net/weixin_30527551/article/details/98882344 https://syncthing.net/downloads/ http ...

  3. cc26a_demo-CppPrimer_动态绑定_多态-代码示范

    //多态性    //从派生类到基类的转换    //引用或者指针既可以指向基类对象,也可以指向派生类对象    //只有通过引用或者指针调用虚函数才会发生动态绑定.    //为什么定义虚的函数?可 ...

  4. SLS编写规范

    SLS编写规范 规范要点说明 首先,状态的执行不可回滚,执行完了就是执行完了,并不会中断回滚,其次,状态的执行,可以反复执行,也就是说一个状态文件,可以多次来进行调用. 在编写状态文件过程中,有以下几 ...

  5. 爬取B站弹幕并且制作词云

    目录 爬取弹幕 1. 从手机端口进入网页爬取找到接口 2.代码 制作词云 1.文件读取 2.代码 爬取弹幕 1. 从手机端口进入网页爬取找到接口 2.代码 import requests from l ...

  6. JavaWeb网上图书商城完整项目--day02-3.regist页面输入框失去焦点进行校验

    当输入框输入数据之后,当输入框失去焦点的时候,我们需要对输入的数据进行校验 l  用户名校验: 用户名不能为空: 用户名长度必须在3 ~ 20之间: 用户名已被注册(需要异步访问服务器). l  登录 ...

  7. Java是如何实现Future模式的？万字详解！

    JDK1.8源码分析项目(中文注释)Github地址: https://github.com/yuanmabiji/jdk1.8-sourcecode-blogs 1 Future是什么? 先举个例子 ...

  8. 【秒懂Java】【第1章_初识Java】02_软件开发

    通过上一篇文章<01_编程语言>,我们了解到 Java是众多编程语言中的其中一种 编程语言可以用来开发软件 因此,我们即将要学习的Java技术,是属于软件开发的范畴.那软件开发的前景如何呢 ...

  9. 最新的一波Vue实战技巧，不用则已，一用惊人

    在Vue中,不同的选项有不同的合并策略,比如 data,props,methods是同名属性覆盖合并,其他直接合并,而生命周期钩子函数则是将同名的函数放到一个数组中,在调用的时候依次调用 在Vue中, ...

  10. MongoDB快速入门教程 （3.3）

    3.4.聚合 3.4.1.什么是聚合? MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等),并返回计算后的数据结果.有点类似sql语句中的 count(*) 例如上图 ...