2 Apr 18
一、三元表达式
三元表达式仅应用于： #逻辑非常简单的情况，分两种情况返回
1、条件成立返回一个值
2、条件不成立返回一个值
def max2(x,y):
if x > y:
return x
else:
return y
def max2(x,y):
return x if x > y else y
print(max2(10,11))
二、函数递归：函数的递归调用即在函数调用的过程中，又直接或间接地调用了函数本身
import sys
print(sys.getrecursionlimit()) # 查讯迭代限制（python对此进行限制以保护内存）
sys.setrecursionlimit(10000) #更改迭代限制；不建议更改。
直接调用
def foo():
print('from foo')
foo()
foo()
间接调用
def bar():
print('from bar')
foo()
def foo():
print('from foo')
bar()
foo()
递归分为两个阶段：
1、 回溯 #注意：一定要在满足某种条件结束回溯，否则无限递归
2、 递推
总结：
1、递归一定要有一个明确地结束条件
2、没进入下一次递归，问题的规模都应该减少
3、在python中没有尾递归优化
def age(n):
if n == 1:
return 18
return age(n-1)+2 #age(4)+2
print (age(5))
推倒思维：
age(5)=age(4)+2 #问题规模为5
age)4)=age(3)+2 #问题规模为4
age(3)=age(2)+2 #问题规模为3
age(2)=age(1)+2 #问题规模为2
age(1)=18
age(n)=age(n-1)+2 # n > 1
age(n)=18 #n=1
items=[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,]]]]]]]]]] #迭代由于普通while循环在于循环需要知道循环多少次，迭代只需知道终止条件即可
def tell(l):
for item in l:
if type(item) is not list:
print(item)
else:
tell(item)
tell(items)
三、匿名函数lambda #一般不会单独使用，通常和其他函数配合使用
f=lambda x,n:x ** n #lambda 参数: 表达式
print(f)
print(f(2,3))
lambda x,y,z:x+y+z
def foo(x,n): #foo=函数的内存地址
return x ** n
强调：
1 匿名的目的就是要没有名字，给匿名函数赋给一个名字是没有意义的
2 匿名函数的参数规则、作用域关系与有名函数是一样的
3 匿名函数的函数体通常应该是 一个表达式,该表达式必须要有一个返回值
lambda匿名函数的应用
#max
求工资最高的那个人是谁
print(max(salaries,key=lambda x:salaries[x])) #key对应的一定要是有返回值的函数
#min
求工资最低的那个人是谁
print(min(salaries,key=lambda x:salaries[x]))
#sorted #结果是一个列表
把薪资字典，按照薪资的高低排序
salaries1=sorted(salaries,key=lambda x:salaries[x]) #默认是升序排
salaries2=sorted(salaries,key=lambda x:salaries[x],reverse=True) #降序
print(salaries1)
print(salaries2)
#map 映衬
nums=[1,2,3,4,5]
res=map(lambda x:x**2,nums)
print(list(res)) #返回的是迭代器，要把内容全用列表的形式取出来有list(res)
names=['alex','wupeiqi','yuanhao','egon']
res=map(lambda x:x+'_NB' if x == 'egon' else x + '_SB',names)
print(list(res))
#reduce 合并 #在python2中是内置的，在python3中放到模块中，需导入
reduce在python3中需要先导入
from functools import reduce
res=reduce(lambda x,y:x+y,range(1,101),100) #若没有初始值，reduce循环两次
print(res)
l=['my','name','is','alex','alex','is','sb']
res=reduce(lambda x,y:x+' '+y,l)
print(res)
#filter #filter只过滤出True的值
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))
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()) #在全局作用域查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__()
# 面向对象里讲
classmethod
staticmethod
property
delattr
hasattr
getattr
setattr
exec
isinstance
issubclass