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. pycharm安装破解方法

    1.pycharm专业版官方下载链接:http://www.jetbrains.com/pycharm/download/#section=windows正常下载并安装 2.从https://gith ...

  2. fiddler下载安装

    1.官网https://www.telerik.com/fiddler 2.按照要求填写 3.傻瓜式安装 4.安装https证书

  3. 快捷符号输入小tip(option,alt键的妙用)

    我们知道特殊符号的输入可以通过上档键(shift)加数字来完成.如!@#$%... -> (shift + 1 2 3 4 5...) 但是少有人知道windows中的alt键,或是macos中 ...

  4. Zookeeper——基本使用以及应用场景（手写实现分布式锁和rpc框架）

    文章目录 Zookeeper的基本使用 Zookeeper单机部署 Zookeeper集群搭建 JavaAPI的使用 Zookeeper的应用场景 分布式锁的实现 独享锁 可重入锁 实现RPC框架 基 ...

  5. 5.kubernetes的服务暴露插件-Traefik

    目录 1.部署traefik 2.准备资源配置清单 3.应用资源配置清单 4.检查创建资源 5.解析域名 6.配置反向代理 7.浏览器访问 部署traefik 在HDSS7-200.host.com上 ...

  6. Git 居然可以用来跟女神聊天？

    Git 是用来做啥的?想必码农朋友都知道,Git 是版本控制软件,是软件开发过程中团队协作不可或缺的软件. 但是,作为版本控制软件的 Git ,能跟聊天工具扯上关系吗?这二者似乎毫无关系,但脑洞大开的 ...

  7. Redis快照原理详解

    本文对Redis快照的实现过程进行介绍,了解Redis快照实现过程对Redis管理很有帮助. Redis默认会将快照文件存储在Redis当前进程的工作目录中的dump.rdb文件中,可以通过配置dir ...

  8. Java闭包概念

    闭包又称词法闭包 闭包最早定义为一种包含<环境成分>和<控制成分>的实体. 解释一:闭包是引用了自由变量的函数,这个被引用的变量将和这个函数一同存在. 解释二:闭包是函数和相关 ...

  9. MySql索引要注意的8个事情

    设计好MySql索引可以让你的数据库查询效率大为提高.设计MySql索引的时候,有一些问题需要值得我们注意的: 1,创建MySql索引 对于查询占主要的应用来说,索引显得尤为重要.很多时候性能问题很简 ...

  10. 深度学习“四大名著”发布！Python、TensorFlow、机器学习、深度学习四件套！

    Python 程序员深度学习的"四大名著": 这四本书着实很不错!我们都知道现在机器学习.深度学习的资料太多了,面对海量资源,往往陷入到"无从下手"的困惑出境. ...