学习笔记☞python 基础☞函数(二)☞python3

函数

lambda表达式(又名匿名函数表达式)

作用：
    创建一个匿名函数对象
    同def类似，但不提供函数名
语法：
    lambda [形参1, 形参2, ……] : 表达式
示例：

def myadd(x, y):
    return x + y


可以改写为：
myadd = lambda x, y: x + y
print(myadd(100, 200))
print(myadd('abc', '100'))

'''
运行结果：
300
abc100
'''

语法说明:

1、lambda 值是一个表达式，它用来创建一个函数对象
2、当lambda表达式调用时，先执行冒号后面的表达式，并返回表达式的结果的引用
3、lambda表达式创建的函数只能包含一条表达式
4、lambda比函数简单，且可以随时创建和销毁，有利于减少程序的耦合度
   
练习：

#! /usr/bin/python3
'''
1、写一个lambda表达式，判断这个数的平方加一能否被5整除，如果能返回True，否则返回False
'''
fx = lambda n: (n ** 2 + 1) % 5 == 0
print(fx(4))
print(fx(3))


#! /usr/bin/python3
'''
2、写一个lambda表达式，求两个变量的最大值：
'''
# mymax=lambda x,y : max(x,y)
mymax = lambda x, y: x if x > y else y
print(mymax(55, 63))

看懂下面的程序在做什么：

def fx(f, x, y):
        r = f(x, y)
        print(r)

    fx((lambda a, b: a + b), 100, 200)
    fx((lambda a, b: a ** b), 3, 4
   

eval 和 esec 函数

eval函数：

    作用：
        把一个字符串当成一个表达式执行，返回表达式执行后的结果
    格式：
        eval(source, globals=None, locals=None)
示例：

x = 100
y = 200
s = 'x+y'
v=eval(s)
print(v)

print(eval('x+y', {'x': 10, 'y': 20}))  # 大括号内为设置的全局变量 结果:30
print(eval('x+y', {'x': 10, 'y': 20}, {'x': 1, 'y': 2}))  # 第二个大括号内为设置的局部变量 结果：3
print(eval('x+y', {'x': 10, 'y': 20}, {'x': 1}))    #结果：21

exec函数：

    作用：
        把一个字符串当成程序来执行
    格式：
        exec(soure, globals=None, local=None)
示例：

s = 'x=100; print("hello"); x += 1; print(x)'
print(s)
exec(s)

'''
自己写一个程序，解释执行用户输入的任何语句
'''
while True:
s=input('请输入语句$ >>>>')
if s=='bye':
    break
eval(s)

函数式编程：

    是指用一系列函数解决问题

函数是一等公民

    1、函数本身是对象可以赋值给变量，复制后变量绑定函数
    2、允许将函数作为实参传入另一个函数
    3、允许函数返回一个函数

函数式编程的好处：

    1、每一个函数完成细小的功能，一系列菡数的任意组合可以解决大的问题
    2、函数仅接收输入并产生输出，不会影响其他全局变量的状态

思考：
    求 1 + 2 + 3 + …… + n 的和

print(sum(range(n+1)))    

练习：
    求1+1/2+1/4+1/8+……+1/2**n

print(sum([1 / 2 ** x for x in range(n + 1)])) 

高阶函数 High Order Function

    什么是高阶函数：

        满足下列条件中的一个的函数即为高阶函数

            1、函数接受一个或多个函数作为参数传入

            2、函数返回一个函数

python内置(builtins)的高阶函数

    map, filter, sorted

map 函数

    map(func, *iterables)   用函数对可迭代对象的每一个元素作为参数计算出新的可迭代对象，当最短的一个可迭代对象不再提供数据时，此可迭代对象生成结果
示例：

#生成一个可迭代对象，要求此可迭代对象可以生成1-9自然数的平方

#! /usr/bin/python3
def power2(x):
    return x ** 2


for x in map(power2, range(1, 10)):
    print(x)
# 求以上数据的和
print(sum(map(power2, range(1, 10))))

示例：
    生成一个可迭代对象，要求次可迭代对象生成1**4,2**3,3**2,4**1  

for x in map(pow,[1,2,3,4],[4,3,2,1]):
    print(x)

练习：   

'''
1、求1**2+2**2+3**2+……9**2的和
'''
s = sum(map((lambda x: x ** 2), range(1, 10)))
print(s)
'''
2、求1**3+2**3+3**3+……9**3的和
'''
s = sum(map((lambda x: x ** 3), range(1, 10)))
print(s)
'''
3、求1**9+2**8+3**7+……9**1的和
'''
s = sum(map(pow, range(1, 10), range(9, 0, -1)))
print(s)

filter 函数：

    格式：
        filter(func,iterable)
    作用：
        筛选可迭代对象iterable中的数据，返回一个可迭代对象，次可迭代对象将对iterable进行筛选
        函数func将对iterable中的每个元素进行求职，返回False时将此数据丢弃，返回True保留此数据
    示例：
       

# isodd函数判断x是否为奇数，是奇数返回True
def isodd(x):
    return x % 2 == 1


# 打印十以内的奇数：
for i in filter(isodd, range(10)):
    print(i)

# 生成10以内所有偶数的列表
l = [i for i in filter(lambda x: x % 2 == 0, range(10))]
print(l)

sorted 函数：

    作用：
        将元可迭代的数据进行排序，生成排序后的列表
    格式：
        sorted(iterable,key=None, reverse=False)
    参数说明：
        iterable    可迭代对象
        key         绑定函数，此函数用来提供一个排序的依据
        reverse     标志是否设置是否降序排序(从大到小)
    示例：

L = [5, -2, -4, 0, 3, 1]
L2 = sorted(L)  
print(L2)                       # L2 = [-4, -2, 0, 1, 3, 5]
L3 = sorted(L, reverse=True)  
print(L3)                       # L3 = [5, 3, 1, 0, -2, -4]
L4 = sorted(L, key=abs)
print(L4)                       # L4 = [0, 1, -2, 3, -4, 5]

示例：

names = ['Tom', 'Jerry', 'Spike', 'Type']
L = sorted(names)   # ['Jerry', 'Spike', 'Tom', 'Type']
# 能否根据名字的长度进行排序？
L = sorted(names, key=len)  # ['Tom', 'Type', 'Jerry', 'Spike']
# 根据名字最后字母排序
L = sorted(names, key=lambda x:x[::-1]) # ['Spike', 'Type', 'Tom', 'Jerry']

递归函数 recursion

    函数直接或间接的调用自身
示例

#直接调用自身

def f():
    f() # 调用自身
f()
print('递归完成')


#函数间接调用自身的实例

def fa():
    fb()
def fb():
    fa()
fa()

递归说明：

    递归一定要控制递归的层数，当符合某一条件时终止递归
    几乎所有递归都能用循环来代替

递归的优缺点

优点：
    递归可以把问题简单化，让路径更为清晰，代码更为简洁
缺点：
    递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果


示例：

#此程序用来示意递归函数的调用
# 以下程序会无限递归，永不终止

def story():   
    print('从前有座山，山上有座庙，庙里有个老和尚讲故事:',end='')
    story()
    print('故事讲完了')
story()


#此程序用参数来控制最大次数为3
def story(times):   #times 代表讲故事的次数
    print('第',times,'遍')
    print('从前有座山，山上有座庙，庙里有个老和尚讲故事:')
    if times>=3:
        return  #不要再讲故事了

    story(times+1)#当前次数加一，再讲一遍
    print('故事讲完了')
story(1)


#此程序用参数来控制最大次数为3
def fx(n):   #times 代表讲故事的次数
    print('现在第',n,'层')
    if n>=3:
        return  #不要再讲故事了

    fx(n+1)#当前次数加一，再讲一遍
    print('递归的第',n,'层结束')
fx(1)
print('程序解释，当前回到了主程序')

'''
运行结果
现在第 1 层
现在第 2 层
现在第 3 层
递归的第 2 层结束
递归的第 1 层结束
程序解释，当前回到了主程序
'''

递归函数的实现方法

    先假设函数已经实现

示例：

'''
求：100+99+98+……+1的和
分析：
    先假设 mysum(x)已经完成，且能求x+x-1+……+1的和
'''
def mysum(x):
    if x==1:
        return 1
    return x+mysum(x-1)
print(mysum(100))

练习：
    1、编写函数myfac(x)计算x的阶乘x!
    5！=5*4*3*2*1

    print(myfac(5)) # 120

    2、写程序计算出1~20的阶乘的和
    1！+2！+3！+……+20！
    思考：
        能否用函数式编程中的高阶函数实现
    3、已知有列表：
    L=[[3,5,8],10,[[13,14],15],18]

    1)写一个函数print_list(lst)打印出列表中所有数字
    print_list(L)

    2)写一个函数sum_list(lst)返回列表中所有数字的和
    print(sum_list(L))  #86

    注：
        type(x)可以返回一个变量的类型
        如：
        >>> type(20) is int #True
        >>> type([1,2,3]) is list # True




    5、开始学生信息管理项目：
        需要两个函数：
            input_student() 返回学生信息的字典的列表
            output_student()    以表格方式打印学生信息
        学生信息：
        姓名(name)    字符串
        年龄(age)     int
        成绩(score)   int

        input_student()调用时等待用户输入学生信息，当输入姓名为空时结束输入，最后将学生信息形成字典存入列表中返回

        def input_student():
            pass
        L=input_student()
            请输入学生姓名：小张
            请输入学生年龄：20
            请输入学生成绩：98

            请输入学生姓名：小李
            请输入学生年龄：23
            请输入学生成绩：100
            请输入学生姓名：<回车>输入结束
        此时列表数据为：
        L=[{'name':'小张',
        'age':20,
        'score':98},
         {'name':'小李',
        'age':23,
        'score':100}]


        def output_student():
            pass
        print(L)    #打印出字典的列表
        output_student(L)   #打印出学生信息的表格如下
        +---------------+---------------+-------------+
        |   name        |   age         |   score     |
        +---------------+---------------+-------------+
        |   小张        |   20          |   98        |
        |   小李        |   23          |   100       |
        +---------------+---------------+-------------+