4/2 三元表达式/函数递归/匿名函数/内置函数

三元表达式

def max2(x,y)

  if x > y:

    return x

  else

    return y

res=max2(10,11)

三元表达式仅应用于:

1 条件成立返回一个值

2 条件不成功返回一个值

def max2(x,y):

  return x if x>y else y

print (max2(2,10))

10

函数递归:函数的递归调用,即在函数调用的过程中,又直接或间接地调用了函数的本身。

直接调用

def foo():

  print (‘fffff‘)

  foo()

间接调用

def bar ()

  print (‘bai‘)

  foo()

def foo():

  print(‘foo‘)

  bar()

递归分为两个阶段

1回溯

  注意一定要在满足某种条件结束回溯,否则的无限递归

2 递推

总结:

1递归一定要有一个明确地结束条件

2每进入下一次递归,问题的规模都应该减少

3在python中没有尾递优化

age(5)=age(4)+2age)4)=age(3)+2age(3)=age(2)+2age(2)=age(1)+2age(1)=18

age(n)=age(n-1)+2 # n > 1age(n)=18            #n=1

def age(n):    if n == 1:        return 18    return age(n-1)+2 #age(4)+2

age(5)

items=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,]]]]]]]]]]def tell(l):    for item in l:        if type(item) is not list:            print(item)        else:            tell(item)

tell(items)

匿名函数def func():  print (‘from func‘)

f=lambda x,n:x ** nprint() print(f(2,3))

强调

1 匿名的目的就是要没有名字,给匿名函数赋给一个名字是没有意义的,

2 匿名函数的参数规则,作用域关系和有名函数是一样的

3匿名函数的函数体通常应该是一个表达式,该表达式必须要有一个返回值

def funcc(x,y,z)

  return x+y+z

lambda x,y,z:x+y+z

salaries={    ‘egon‘:3000,    ‘alex‘:100000000,    ‘wupeiqi‘:10000,    ‘yuanhao‘:2000}

求工资最高的那个人是谁def get(k):    return salaries[k]print(max(salaries,key=get)) #‘egon‘ 3000for k in salaries:    print(k) # 告诉max,比较的依据,k,salaries[k]

print(max(salaries,key=lambda x:salaries[x])) #‘egon‘ 3000

求工资最低的那个人是谁print(min(salaries,key=lambda x:salaries[x]))

把薪资字典,按照薪资的高低排序nums=[1,11,9]nums=sorted(nums) #默认是升序print(nums)

salaries={    ‘egon‘:3000,    ‘alex‘:100000000,    ‘wupeiqi‘:10000,    ‘yuanhao‘:2000}
salaries=sorted(salaries) # 默认按照字典的键排序print(salaries)

salaries=sorted(salaries,key=lambda x:salaries[x])  #默认是升序排salaries=sorted(salaries,key=lambda x:salaries[x],reverse=True) #降序print(salaries)

lambda与map,reduce,filternums=[1,2,3,4,5]res=map(lambda x:x**2,nums)print(list(res))

names=[‘alex‘,‘wupeiqi‘,‘yuanhao‘]res=map(lambda x:x+‘_SB‘,names)print(list(res))

names=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘egon‘]res=map(lambda x:x+‘_NB‘ if x == ‘egon‘ else x + ‘_SB‘,names)print(list(res))

from functools import reduceres=reduce(lambda x,y:x+y,range(1,101),100)res=reduce(lambda x,y:x+y,range(1,101))print(res)

l=[‘my‘,‘name‘,‘is‘,‘alex‘,‘alex‘,‘is‘,‘sb‘]res=reduce(lambda x,y:x+‘ ‘+y+‘ ‘,l)print(res)

filternames=[‘alex_sb‘,‘wxx_sb‘,‘yxx_sb‘,‘egon‘]res=filter(lambda x:True if x.endswith(‘sb‘) else False,names)res=filter(lambda x:x.endswith(‘sb‘),names)print(list(res))

ages=[18,19,10,23,99,30]res=filter(lambda n:n >= 30,ages)print(list(res))

salaries={    ‘egon‘:3000,    ‘alex‘:100000000,    ‘wupeiqi‘:10000,    ‘yuanhao‘:2000}res=filter(lambda k:salaries[k] >= 10000,salaries)print(list(res))

内置函数

# print(abs(-1))# print(all([1,‘a‘,True])) # 列表中所有元素的布尔值为真,最终结果才为真# print(all(‘‘)) # 传给all的可迭代对象如果为空,最终结果为真

# print(any([0,‘‘,None,False])) #列表中所有元素的布尔值只要有一个为真,最终结果就为真# print(any([])) # 传给any的可迭代对象如果为空,最终结果为假

# print(bin(11)) #十进制转二进制# print(oct(11)) #十进制转八进制# print(hex(11)) #十进制转十六进制

# print(bool(0)) #0,None,空的布尔值为假

# res=‘你好egon‘.encode(‘utf-8‘) # unicode按照utf-8进行编码,得到的结果为bytes类型# res=bytes(‘你好egon‘,encoding=‘utf-8‘) # 同上# print(res)

# def func():#     pass# print(callable(‘aaaa‘.strip)) #判断某个对象是否是可以调用的,可调用指的是可以加括号执行某个功能

# print(chr(90)) #按照ascii码表将十进制数字转成字符# print(ord(‘Z‘)) #按照ascii码表将字符转成十进制数字

# print(dir(‘abc‘)) # 查看某个对象下可以用通过点调用到哪些方法

# print(divmod(1311,25)) # 1311 25

# 将字符内的表达式拿出运行一下,并拿到该表达式的执行结果# res=eval(‘2*3‘)# res=eval(‘[1,2,3,4]‘)# res=eval(‘{"name":"egon","age":18}‘)# print(res,type(res))

# with open(‘db.txt‘,‘r‘,encoding=‘utf-8‘) as f:#     s=f.read()#     dic=eval(s)#     print(dic,type(dic))#     print(dic[‘egon‘])

# s={1,2,3}# s.add(4)# print(s)

# 不可变集合# fset=frozenset({1,2,3})

# x=111111111111111111111111111111111111111111111111111111111111111111111111111111111111# # print(globals()) # 查看全局作用域中的名字与值的绑定关系# # print(dir(globals()[‘__builtins__‘]))# def func():#     x=1#     print(locals())# # func()# print(globals())

# 字典的key必须是不可变类型# dic={[1,2,3]:‘a‘}# 不可hash的类型list,dict,set==  可变的类型# 可hash的类型int,float,str,tuple ==  不可变的类型# hash()

# def func():    """    帮助信息    :return:    """    # pass

# print(help(max))

# len({‘x‘:1,‘y‘:2}) #{‘x‘:1,‘y‘:2}.__len__()

# obj=iter(‘egon‘) #‘egon‘.__iter__()# print(next(obj)) #obj.__next__()

原文地址:https://www.cnblogs.com/seanliang/p/8696141.html

时间: 2025-01-13 12:32:09

4/2 三元表达式/函数递归/匿名函数/内置函数的相关文章

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

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数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基础第十一天——内置函数的补充、内置函数与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): '''定义

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

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'''函数的参数的分类:必选参数默认参数可变参数关键字参数命名关键字参数 调用的顺序就是,必选参数-默认参数-可变参数-命名关键字参数-关键字参数