函数递归+匿名函数+内置函数day15

一、函数递归

什么是函数递归:

  函数递归调用是一种特殊的嵌套调用,在调用一个函数的过程中,又直接或间接地调用了该函数本身。

其中,函数的递归有明确的结束条件,不能无限制的调用,否则会撑破内存,在Python中限定递归最多调用1000层。

1000层这个值是大概的数值,这个数值可以通过Python内置的功能进行更改。

递归必须要有两个明确的阶段:

  递推:一层层递归调用下去,强调每次进入下一次递归,问题规模都在减小

  回溯:递归必须要有一个明确的结束条件,在满足该条件时结束递推,开始一层层回溯

  其中,递归的精髓在于通过不断的重复逼近一个最终结果。

循环(while)能做的,递归都可以,为什么还要递归?

  因为相较于循环,递归无须确定循环次数,只需确定结束条件。

举个例子,递归的应用:

二分法:

有个从小到大排列对的列表,判断某个值是否在里面。

nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,312]
def search(search_num,nums):
    print(nums)
    if len(nums)==0:
        print(‘not exists‘)
        return
    mid_index=len(nums)//2
    if search_num>nums[mid_index]:
        nums=nums[mid_index+1:]
        search(search_num,nums)
    elif search_num<nums[mid_index]:
        nums=nums[:mid_index]
    else:
        print(‘find it‘)
search(31,nums)

 二、匿名函数

有名函数:基于函数名重复使用

匿名函数:没有绑定名字的下场就是使用一次就被回收了。

定义:

lambda x,y: x+y

其中冒号后面的值就相当于有名函数里的return 后面的值

res=( lambda x,y: x+y)(1,2)

max 工作原理:

1、首先将可迭代对象变成迭代器对象

2、res=next(迭代器对象)将res当作参数传给key指定的函数,然后将该函数的返回值当成判断的依据。

map的工作原理:

1、首先将可迭代对象变成迭代器对象

2、res=next(迭代器对象)将res当作参数传给第一参数指定的函数,然后将该函数的返回值当成结果之一

filter工作原理:

1、首先将可迭代对象变成迭代器对象

2、res=next(迭代器对象)将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res

三、常用内置函数

1、

res=‘你好’.encode(‘utf-8‘)

res=bytes(‘你好’,encoding=‘utf-8‘)

2、

参考ASCII码将数字转成对应的字符

print(chr(65))      #‘A‘

参考ASCII码将字符转成对应的数字

print(ord(‘a‘))      #97

3、

将两个数进行取模运算,得到商和余数

print(divmod(10,3))      #(3, 1)

4、

l=[‘a‘,‘b‘,‘c‘]      #枚举
for item in enumerate(l):
print(item)

5、

l=‘[1,2,3]‘      #将字符串中的东西拿出了执行一遍
l1=eval(l)
print(l1,type(l1))
print(l1[0])

6、

print(round(3.3))  #四舍五入

7、

print(sum(range(101)))  #求和

8、

将字符串变成模块名

module=input(‘请输入你要导入的模块名>>: ‘).strip() #module=‘asdfsadf‘
m=__import__(module)
print(m.time())

原文地址:https://www.cnblogs.com/xiaocao736427460/p/9183457.html

时间: 2024-11-09 01:42:46

函数递归+匿名函数+内置函数day15的相关文章

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

8.5高阶函数、递归函数和内置函数

高阶函数.递归函数和内置函数 高阶函数和递归函数 #函数名可以进行赋值,可以作为函数参数,可以作为返回值 #高阶函数:允许导入函数作为参数导入或者返回值为函数 def f(n): return n*n def fun(a,b,fun1): an1=fun1(a)+fun1(b) return (an1) print(fun(1,2,f)) def sqrt(n): return n*n def function(a,b,function1): answer=function1(a)+functi

[JSP][JSTL]页面调用函数--它${fn:}内置函数、是推断字符串是空的、更换车厢

页面中调用函数--之${fn:}内置函数 函数描写叙述 fn:contains(string, substring) 假设參数string中包括參数substring,返回true fn:containsIgnoreCase(string, substring) 假设參数string中包括參数substring(忽略大写和小写),返回true fn:endsWith(string, suffix) 假设參数 string 以參数suffix结尾,返回true fn:escapeXml(strin

python基础12_匿名_内置函数

一个二分查找的示例: # 二分查找 示例 data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35, 36, 66] def binary_search(dataset, find_num): print(dataset) if len(dataset) > 1: mid = int(len(dataset) / 2) if dataset[mid] == find_num: # find it print

Python基础第十一天——内置函数的补充、内置函数与lambda、递归

一.拾遗 1.生成器表达式形式的多个函数之间的协同工作. 例:做一包子吃一个包子 优点:更省内存. 以上例子的原理: 重点★★★★★ 源代码: import time import random # 装饰器 def init(func): '''生成器表达式的初始化''' def wrapper(*args,**kwargs): g=func(*args,**kwargs) next(g) return g return wrapper def cook(people,count): '''定义

day16 函数的用法:内置函数

一共有68个内置函数: #内置:python自带 # def func(): # a = 1 # b = 2 # print(locals()) # print(globals()) # func() # range(100) #[0,100) # range(5,100) #[5,100) # range(1,100,2) #可迭代对象,可以for循环,惰性运算 # range(100).__iter__() # iterator = iter(range(100)) #拿到一个迭代器 # p

Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.

Python-Day3知识点——深浅拷贝、函数基本定义、内置函数

一.深浅拷贝 import copy #浅拷贝 n1={'k1':'wu','k2':123,'k3':['carl',852]} n2=n1 n3=copy.copy(n1) print(id(n1)) print(id(n2)) print(id(n3)) print(id(n1['k3'])) print(id(n3['k3'])) #深拷贝 n4=copy.deepcopy(n1) print(id(n4)) print(id(n1['k3'])) print(id(n4['k3']))

【Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数】

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.

高阶函数、递归函数、内置函数

这里我们学习的是: 高阶函数 递归函数 内置函数 参数分类: # 这里的参考文章是:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431752945034eb82ac80a3e64b9bb4929b16eeed1eb9000'''函数的参数的分类:必选参数默认参数可变参数关键字参数命名关键字参数 调用的顺序就是,必选参数-默认参数-可变参数-命名关键字参数-关键字参数