三元表达式
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)+2
age)4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)=18
age(n)=age(n-1)+2 # n > 1
age(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 ** n
print（）
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‘ 3000
for 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，filter
nums=[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 reduce
res=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)
filter
names=[‘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__()