Python之旅.第三章.函数4.01/4.02

一、三元表达式

#普通的判断大小函数
def max2(x,y):
    if x > y:
        return x
    else:
        return y

res=max2(10,11)
print(res)

x=12
y=11

#三元表达式仅应用于：
#1、条件成立返回 一个值
#2、条件不成立返回 一个值
语法：
return 成立得到的值 if 表达式 else 不成立得到值

#用三元表达式简写的函数表达式
def max2(x,y):
    return x if x > y else y

print(max2(10,11))

二、函数递归

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

直接调用
def foo():
    print('from foo')
    foo()

foo()
#无限循环调用foo()

间接调用
def bar():
    print('from bar')
    foo()

def foo():
    print('from foo')
    bar()

foo()
#无限互相调用

递归分为两个阶段
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
#递归获得age5的值
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 foo(x,n): #foo=函数的内存地址
#     return x ** n
#无函数名定义函数
# f=lambda x,n:x ** n
# # print(f)
# print(f(2,3))
# print(f(2,4))

#强调：
#1 匿名的目的就是要没有名字，给匿名函数赋给一个名字是没有意义的
#2 匿名函数的参数规则、作用域关系与有名函数是一样的
#3 匿名函数的函数体通常应该是 一个表达式,该表达式必须要有一个返回值
# def func(x,y,z):
#     return x+y+z

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

#lambda匿名函数的应用：
#max,min,sorted,
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)

四、内置参数

# 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__()

# 面向对象里讲
classmethod
staticmethod
property

delattr
hasattr
getattr
setattr

exec

isinstance
issubclass

# print(pow(2,3,3)) #2 ** 3 % 3

# l=[1,4,3,5]
# res=reversed(l)
# print(list(res))
# print(l)

# print(round(3.5))
# print(round(3.4))

# sc=slice(1,5,2) #1:5:2
# l=['a','b','c','d','e','f']
# # print(l[1:5:2])
# print(l[sc])
#
# t=(1,2,3,4,5,6,7,8)
# # print(t[1:5:2])
# print(t[sc])

# sum
# print(sum([1,2,3,4]))

# vars
# vars()

# zip
left='hello'
right={'x':1,'y':2,'z':3}

res=zip(left,right)
print(list(res))

五、列表生成式与生成器表达式

1、列表生成式
#创建一个列表往列表里添加值
l=[]
for i in range(100):
    l.append('egg%s' %i)
print(l)
#列表生成式，把上方代码用列表生成式写
l=['egg%s' %i for i in range(100)]
l=['egg%s' %i for i in range(1000) if i > 10]
print(l)

2、生成器表达式
#区别，生成器表达式用小括号，切生成器表达式是一个一个值获得。
l=('egg%s' %i for i in range(1000) if i > 10)
print(next(l))
print(next(l))
# print(next(l))

3、练习题
names=['egon','alex_sb','wupeiqi','yuanhao','lxx']
res=map(lambda x:x.upper(),names)
names=list(res)
print(names)

names=['egon','alex_sb','wupeiqi','yuanhao','lxx']
names=[name.upper() for name in names]
print(names)

names=['egon','alex_sb','wupeiqi','yuanhao','lxx']
names=[len(name) for name in names if not name.endswith('sb')]
print(names)

nums=[]
with open('a.txt','r',encoding='utf-8') as f:
    for line in f:
        # print(len(line))
        nums.append(len(line))

print(max(nums))

with open('a.txt','r',encoding='utf-8') as f:
    nums=(len(line) for line in f)

    print(nums)
    print(next(nums))
    print(next(nums))
    print(next(nums))
    print(max(nums))
    print(max(nums))

    max((len(line) for line in f))
    print(max(len(line) for line in f))