python基础（11）——函数式编程

一、函数式编程

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

  示列:
     求 1 + 2 + 3 + 4 + .... + 100的和

# 方法1
s = 0
for x in range(1,101):
    s += x
print(s)

# 方法2
print(sum(range(1,101)))

函数的可重入性:

      当一个函数的输入一定，则输出必然一定的函数称为可重入函数

  说明:
      可重入函数内一定不会访问除局部变量以外的变量
  示例:
     # 可重入函数:

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


print(myadd(100, 200))  # 300

    # 不可重入函数:

y = 200

def myadd(x):
    return x + y


print(myadd(100))  # 300
y = 300
print(myadd(100))  # 400

二、高阶函数 High Order Function

     1、 什么是高阶函数:
         满足下列条件中的一个的函数即为高阶函数
            1. 函数接收一个或多个函数作为参数传入
            2. 函数返回一个函数

     2、python内置的高阶函数:
            map, filter, sorted

1、map函数:

    map(func, *iterable)  返回一个可迭代对象,此可迭代对象用函数func对可迭代对象iterable中的每一个元素作为参数计算后得到新的数据

示例1：

# map函数示例
def power2(x):
    return x ** 2

for x in map(power2, range(1, 10)):
    print(x)  # 1 4 9 16 .... 81

   练习 ：
      1. 求: 1**2 + 2**2 + 3**2 + .... + 9**2的和

# 方法1
def power2(x):
    # print("power2被调用!, x=", x)
    return x ** 2
s = 0  # 用来保存和
for x in map(power2, range(1, 10)):
    s += x
print(s)


# 方法2
s = 0
for x in map(lambda x: x ** 2, range(1, 10)):
    s += x
print(s)


# 方法３
print(sum(map(lambda x: x**2, range(1, 10))))

      2. 求: 1**3 + 2**3 + 3**3 + .... + 9**3的和

#方法1
def mysum2(x):
    print("mysum1被调用!,x=",x)
    return x**3
s = 0
for x in map(mysum2,range(1,10)):
    s += x
print(s)
#方法2
s=0
for x in map(lambda x: x ** 3, range(1,10)):
    s += x
print(s)
# 方法3
print(sum(map(lambda x: x**3, range(1, 10))))

示例2：

#   生成一个可迭代对象，此可迭代对象能够提供:
#   1**4, 2**3, 3**2, 4**1
def mypow(x, y):
    return x ** y

for i in map(mypow, [1, 2, 3, 4], (4, 3, 2, 1)):
    print(i)

print('-------------')
for i in map(pow, [1, 2, 3, 4], (4, 3, 2, 1)):
    print(i)

print("=============")
for i in map(pow,
             [1, 2, 3, 4],
             (4, 3, 2, 1),
             range(5, 1000)):
    print(i)  #1%5=1  8%6=2  9%7=2  4%8=4

 练习:
       求 1**9 + 2**8 + 3**7 + .... + 9**1的和

 答案:
      print(sum(map(pow, range(1, 10), range(9, 0, -1))))

2、filter 函数:

   filter(function, iterable)
  作用:
      1. 筛选可迭代对象iterable中的数据,返回一个可迭代对象,此可迭代对象只返回iterable中附合条件的数据
      2. function将对iterable中提供的每个数据进行求布尔值，如果为True则保留，返回False 则丢弃此数据

# 此函数判断x是否为奇数，如果为奇数返回Ture，否则返回False
def isodd(x):
    return x % 2 == 1

for x in filter(isodd, range(10)):
    print(x)  #1 3 5 7 9

L = list(filter(isodd, range(10)))
print('L =', L)

  练习:
     1. 将 1 ~ 20的偶数用filter生成可迭代对象后，将可迭代对象生成的数据存于列表中
         最终结果:
         L = [2, 4, 6, 8, ... 18, 20]

def iseven(x):  # 判断x是否是偶数，是偶数返回True,...
    if x % 2 == 0:
        return True
    return False

# L = list(filter(iseven, range(1, 21)))
L = list(filter(lambda x: x % 2 == 0, range(1, 21)))
print(L)

     2. 用filter函数将 1~100之间所有的素数放入到列表L中
        print(L)  # [2, 3, 5, 7, 11, ....]

def isprime(x):
    if x < 2:
        return False
    for i in range(2, x):
        if x % i == 0:  # 一但整数x就一定不是素数
            return False
    return True

L = list(filter(isprime, range(100)))
print(L)

3、sorted 函数

   作用:
     将原可迭代对象的数据进行排序，生成排序后的列表
   函数参数格式:
     sorted(iterable, key=None, reverse=False)
   说明:
      iterable 可迭代对象
      key       函数是用来提供一个值，这个值将作为排序的依据，如果不给出key函数，则用原数据的值进行比较和排序
      reverse 标志用来设置是否降序排序
   示例:
     L = [5, -2, -4, 0, 3, 1]
     L2 = sorted(L)  # [-4, -2, 0, 1, 3, 5]
     L3 = sorted(L, reverse=True) #[5,3,1,0,-2,-4]
     L4 = sroted(L, key=abs) # [0, 1, -2, 3, -4, 5] 按绝对值
     L5 = sorted(L, key=abs, reverse=True) # [5, -4, 3, -2, 1, 0]
     names = ['Tom', 'Jerry', 'Spike', 'Tyke']
     L6 = sorted(names)  # ['Jerry', 'Spike', 'Tom', 'Tyke']
     L7 = sorted(names, key=len)  # ['Tom', 'Tyke', 'Jerry', 'Spike']

  练习:
     names = ['Tom', 'Jerry', 'Spike', 'Tyke']
     排序的依据为字符串的反序
             'moT' 'yrreJ'  'ekipS'  'ekyT'

     结果:  ['Spike', 'Tyke', 'Tom', 'Jerry']

names = ['Tom', 'Jerry', 'Spike', 'Tyke']
# 排序的依据为字符串的反序
#           'moT' 'yrreJ'  'ekipS'  'ekyT'
def k(s):
    return s[::-1]

L = sorted(names, key=k)
print(L)  # ['Spike', 'Tyke', 'Tom', 'Jerry']

三、递归函数 recursion

   递归是指 函数直接或间接的调用自身

1、递归示例:

   # 函数直接调用自身
    def f():
        f()  # 直接调用自身
    f()
    print("递归完成")

# 此示例示意递归 直接调用自身
def f():
    print("从前有座山，山上有座庙,庙里有个老和尚讲故事：")
    f()  # 直接调用自身

print("开始讲故事")
f()
print("递归完成")

  # 函数间接调用自身
    def fa():
        fb()
    def fb():
        fa()
    fa()
    print("递归完成")

2、递归说明:

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

3、递归的优缺点:

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

4、递归调用分为两个阶段:

   递推阶段:
          从原问题出发，按递归公式递推，从未知到已知，最终达到递归终止条件
   回归阶段:
          按递归终止条件求出结果，逆向逐步代入递归公式，回归到原问题求解

5、示例:

   限制递归层数的示例:

# 限制递归层数的示例:
def fx(n):
    print("递归进入第", n, '层')
    if n == 3:
        return
    fx(n + 1)
    print("递归退出第", n, '层')

fx(1)  # 调用
print("程序结束")

   递归求阶乘示例见:

# 1. 给出一个数n,写一个函数myfac(n)来计算n!(n的阶乘)
#   n! = 1*2*3*4*....*n
#     print(myfac(5))  # 120

def myfac(n):
    # 用循环来实现
    s = 1
    for i in range(1, n + 1):
        s *= i
    return s

# 用递归来实现
# 5!  = 5 * 4!
# 5!  = 5 * 4 * 3!
# 5!  = 5 * 4 * 3　* 2!
# 5!  = 5 * 4 * 3　* 2 * 1!
# 5!  = 5 * 4 * 3　* 2 * 1
# 5!  = 5 * 4 * 3　* 2
# 5!  = 5 * 4 * 6
# 5!  = 5 * 24
# 5!  = 120


def myfac(n):
    if n == 1:  # 知道1! == 1
        return 1
    # 如果n不是1,则递推到下一级求解
    return n * myfac(n - 1)


print(myfac(5))  # 120

练习:
   用递归实现求和:
     def mysum(n):
         # 返回 1 + 2 + 3 + 4 + .... + n的和
         ...

    print(mysum(100))  # 5050

def mysum(n):
    if n == 1:
        return 1
    return n + mysum(n - 1)

print(mysum(100))  # 5050

四、闭包 closure

1、什么是闭包
       闭包是指引用了此函数外部变量的函数
       如果一个内嵌函数访问了外部嵌套函数的变量,则这个内嵌函数就是闭包

2、闭包必须满足三个条件:
     1. 必须有一个内嵌函数
     2. 内嵌函数必须引用外部函数中的变量
     3. 外部函数返回值必须是内嵌函数

#  写一个函数来创建 x的y次方的函数
def make_power(y):
    def fn(x):
        return x ** y
    return fn

pow2 = make_power(2)
print('5的方平是:', pow2(5))

def pow3(x):
    return x ** 3

pow3 = make_power(3)
print('6的三次方是:', pow3(6))
print('5的三次方是:', pow3(5))

pow10 = make_power(10)
print("2的十次方法:", pow10(2))

# 用闭包来创建任意的函数
   # f(x)  = ax2 + bx + c
def get_fx(a, b, c):
    def fx(x):
        return a * x ** 2 + b * x + c
    return fx

f123 = get_fx(1, 2, 3)
print(f123(20))
print(f123(50))

f654 = get_fx(6, 5, 4)
print(f654(10))  # ...

  练习:
     已知有五位朋友在一起
        第五个人说它比第四个人大2岁
        第四个人说它比第三个人大2岁
        第三个人说它比第二个人大2岁
        第二个人说它比第一个人大2岁
        第一个人说它10岁
    编写程序:
       1) 算出第5个人几岁
       2) 算出第3个人几岁

def age(n):  # n代表第n个人
    if n == 1:
        return 10
    return age(n - 1) + 2


print(age(5))
print(age(3))

练习:

   1. 写程序算出1~20 的阶乘的和
     1! + 2! + 3! + 4! + .... + 20!

def myfac(n):
    '''求阶乘'''
    s = 1
    for i in range(1, n + 1):
        s = s * i  # s *= i
    return s


def sum_factorial(n):
    # 方法2
    # return sum(map(myfac, range(1, n + 1)))
    # 方法1
    s = 0
    for i in range(1, n + 1):
        s += myfac(i)  # s += n!
    return s

print(sum_factorial(20))

  2. 已知有列表:
         L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20]
     1) 写一个函数 print_list(lst) 打印出所有的数字
         print_list(L)  # 3 5 8 10 13 ....
     2) 写一个函数 sum_list(lst) 返回列表中所有数字的和
         print(sum_list(L))  # 106
     注:
        type(x) 函数可以返一个对象的类型
        如:
           >>> type(20) is int  # True
           >>> type([3, 5, 8]) is list  # True
           >>> type(20) is list  # False

L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20]
def print_list(lst):
    for x in lst:
        if type(x) is list:  # 是列表
            print_list(x)
        else:  # 是数字
            print(x)

print_list(L)  # 3 5 8 10 13 ....

# L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20]
def sum_list(lst):
    s = 0
    for x in lst:
        if type(x) is int:
            s += x
        elif type(x) is list:
            print(x)
            s += sum_list(x)  # 求 x绑定的列表的和　

    return s


print('和是:', sum_list(L))  # 106

   3. 改写之前的学生信息的程序,要求添加四个功能:
       | 5)  按学生成绩高-低显示学生信息 |
       | 6)  按学生成绩低-高显示学生信息 |
       | 7)  按学生年龄高-低显示学生信息 |
       | 8)  按学生年龄低-高显示学生信息 |

def input_student():
    L = []  # 创建一个新的列表，用此列表准备保存学生信息
    # 录入学生信息
    while True:
        n = input("请输入姓名: ")
        if not n:
            break
        a = int(input("请输入年龄: "))
        s = int(input('请输入成绩: '))
        # 创建一个新的字典，把学生的信息存入字典中
        d = {}  # 每一次都重新创建一个新的字典
        d['name'] = n
        d['age'] = a
        d['score'] = s
        L.append(d)
    return L

def get_chinese_char_count(x):
    count = 0  # 先假设个数为0
    for ch in x:
        # 如果ch为中文字典,则count 做加一操作
        if ord(ch) > 127:
            count += 1
    return count

    
def output_student(L):
    print("+---------------+----------+----------+")
    print("|     name      |   age    |   score  |")
    print("+---------------+----------+----------+")
    for d in L:
        n = d['name']
        a = d['age']
        s = d['score']
        chinese_cnt = get_chinese_char_count(n)
        print('|%s|%s|%s|' % (n.center(15-chinese_cnt),
                              str(a).center(10),
                              str(s).center(10)
                              )
              )

    # print("|    tarena     |    20    |     99   |")
    # print("|     name2     |    30    |     88   |")
    print("+---------------+----------+----------+")


def del_student(L):
    n = input('请输入要删除的学生的姓名: ')
    print("正在删除....", n)


def modify_student_score(L):
    print("正在修改学生成绩....")


def print_info_by_score_desc(L):
    def get_score(d):  # d是字典
        return d['score']

    L2 = sorted(L, key=get_score, reverse=True)
    output_student(L2)


def print_info_by_score_asc(L):
    def get_score(d):  # d是字典
        return d['score']

    L2 = sorted(L, key=get_score)
    output_student(L2)

def print_info_by_age_desc(L):
    L2 = sorted(L, key=lambda d: d['age'], reverse=True)
    output_student(L2)


def print_info_by_age_asc(L):
    L2 = sorted(L, key=lambda d: d['age'])
    output_student(L2)


def show_menu():
    print("+---------------------------------+")
    print("| 1)  添加学生信息                |")
    print("| 2)  显示学生信息                |")
    print("| 3)  删除学生信息                |")
    print("| 4)  修改学生成绩                |")
    print("| 5)  按学生成绩高-低显示学生信息 |")
    print("| 6)  按学生成绩低-高显示学生信息 |")
    print("| 7)  按学生年龄高-低显示学生信息 |")
    print("| 8)  按学生年龄低-高显示学生信息 |")
    print("| q)  退出                        |")
    print("+---------------------------------+")

def main():
    L = []
    while True:
        show_menu()
        s = input("请选择: ")
        if s == 'q':
            break
        elif s == '1':
            L += input_student()
        elif s == '2':
            output_student(L)
        elif s == '3':
            del_student(L)
        elif s == '4':
            modify_student_score(L)
        elif s == '5':
            print_info_by_score_desc(L)
        elif s == '6':
            print_info_by_score_asc(L)
        elif s == '7':
            print_info_by_age_desc(L)
        elif s == '8':
            print_info_by_age_asc(L)

main()