PYTHON1.day11(n)

day10回顾
   函数名是变量，它用来绑定"函数"
     函数可以作为参数传入另一个函数
     函数可以返回另一个函数
   函数的嵌套定义
   def f1():
       def f2():
           pass
       f2()

四个作用域:
   局部作用域
   外部嵌套函数作用域
   全局作用域
   内建作用域
LEGB

global 语句
nonlocal 语句

lambda 表达式
   作用:
     创建简单的匿名函数
   语法:
      lambda 形参列表: 表达式
     等同于:
       def xxxx(形参列表):
           return 表达式
  
eval(字符串, globals=None, locals=None) 函数
exec(字符串, globals=None, locals=None) 函数

day11 笔记:
  
函数式编程 Functional Programming
   函数式编程是指用一系列函数解决问题

好处:
   用每一个函数完全细小的功能，一系列函数的任意组合可以完成大问题
   函数仅接受输入并产生输出，不包含任何能影响输出的内部状态

函数的可重入性
   当一个函数没有访问除局部变量以外的变量，则此函数为可重入函数

  说明:
     可重入函数输入一定．结果必然一定
   示例:
     # 可重入函数:
     def myadd1(x, y):
         return x + y
     # 不可重入函数
     s = 0
     def myadd2(x, y):
         global s
         s += x + y
         return s

高阶函数 High Order Function
什么是高阶函数:
   满足下列条件中的一个的函数即为高阶函数
     1. 函数接收一个或多个函数作为参数传入
     2. 函数返回一个函数
  
python 内置的高阶函数:
   map, filter, sorted

map 函数
   参数格式:
     map(func, iterable, ...)
   参数:
     func 对可迭代对象的数据进行处理的函数,函数的参数必须
        与可迭代对象的个数相同
     iterable, 一个或多个可迭代对象,用来给map提供数据
   返回值:
     可迭代对象
   示例见:
     map.py
     map2.py

# map.py


# 此示例示意map的用法
def power2(x):
    print("power2被调用! x=", x)
    return x ** 2

# 生成一个可迭代对象,此可迭代对象可以生成1~9自然数的平方
# 1 4 9 16 25 36 .... 81

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

# 求:
#   1 + 4 + 9 + 16 + .... + 81的和
print(sum(map(power2, range(1, 10))))

# map2.py

# 生成一个可迭代对象,此可迭代对象可以生成
#   1**4, 2**3, 3**2, 4**1
# pow(x, y, z=None)  内建函数


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

print('-----------')
for x in map(pow, [1,2,3,4],
                   [4, 3, 2, 1, 0],
                   range(5, 10)):
    print(x)  # 1, 2, 2, 4

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

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



# 1. 求:
#   1**2 + 2**2 + 3**2 + .... + 9**2的和
# 方法1
# def power2(x):
#     return x ** 2
# print(sum(map(power2, range(1, 10))))

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

# 2. 求:
#   1**3 + 2**3 + 3**3 + .... + 9**3的和
print(sum(map(lambda x: x**3, range(1, 10))))

# 3. 求:
#   1**9 + 2**8 + 3**7 + .... + 9**1的和
print(sum(map(pow, range(1, 10), range(9, 0, -1))))

filter 函数
   参数格式:
     filter(func, iterable)
   参数说明:
     func 含有一个形参的数据处理函数,此函数传入的值为iterable
          中提供的数据,func将对iterable中的每个元素进行求布尔
          值,返回True则保留此数据,返回False则将此数据丢弃
     iterable 为提供数据的可迭代对象
   返回值:
     可迭代对象
   作用:
     筛选数据
   示例见:
     filter.py

# filter.py

def is_odd(x):
    '''此函数判断x是否是奇数,是奇数返回True,否则返回False'''
    # print(x % 2 == 1)
    return x % 2 == 1

# 打印1 ~ 20 的奇数:
for x in filter(is_odd, range(20)):
    print(x)

print('-------------')
for x in filter(lambda x: x % 2 == 1, range(10)):
    print(x)

# 生成20以内的全部偶数(不包含20)的列表
L = list(filter(lambda x: x % 2 == 0, range(20)))
print(L)
L2 = [x for x in filter(lambda x: x % 2 == 0, range(20))]
print("L2=", L2)

练习:
   1. 用filter 生成能够提供偶数可迭代对象,生成1 ~ 20 的偶数,
      将这些偶数存于列表中,再打印这个列表(不包含20)

  2. 用filter函数,将1~100之间所有的素数prime 放入到列表中,
      再打印这个列表

#   1. 用filter 生成能够提供偶数可迭代对象,生成1 ~ 20 的偶数,
#      将这些偶数存于列表中,再打印这个列表(不包含20)

flt = filter(lambda x: x % 2 == 0, range(1, 20))
L = list(flt)
print(L)  # [2, 4, 6, 8 ...]

L2 = [x for x in flt]
print("L2=", L2)  # 空列表

#   1. 用filter 生成能够提供偶数可迭代对象,生成1 ~ 20 的偶数,
#      将这些偶数存于列表中,再打印这个列表(不包含20)

L = list(filter(lambda x: x % 2 == 0, range(1, 20)))
print(L)  # [2, 4, 6, 8 ...]

L2 = [x for x in filter(lambda x: x % 2 == 0, range(1, 20))]
print("L2=", L2)  # 空列表

#   2. 用filter函数,将1~100之间所有的素数prime 放入到列表中,
#      再打印这个列表


# 写一个函数,is_prime(x), 判断如果x是素数返回True, 否则返回False
def is_prime(x):
    if x < 2:  # 小于2的数没有素数
        return False
    # 大于等于2的数.如果能被2, 3, 4, ... x -1 整数,就不是素数
    for i in range(2, x):
        if x % i == 0:
            return False  # x不是素数
    # 走到此处,则x一定为素数
    return True

# 方法1
L1 = list(filter(is_prime, range(100)))
print("L1=", L1)

L2 = [x for x in filter(is_prime, range(100))]
print("L2=", L2)

L3 = [x for x in range(100) if is_prime(x)]
print("L3=", L3)

sorted 函数:
   作用:
     将原可迭代对象的数据进行排序,生成排序后的列表
   格式:
     sorted(iterable, key=None, reverse=False)
   参数说明:
     iterable  用来提供数据的可迭代对象
     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 = sorted(L, key=abs)   # L4=[0, 1, -2, 3, -4, 5]

    names = ['Tom', 'Jerry', 'Spike', 'Tyke']
     sorted(names)  # ['Jerry', 'Spike', 'Tom', 'Tyke']
     sorted(names, key=len)

练习:
   names = ['Tom', 'Jerry', 'Spike', 'Tyke']
   排序的依据为字符串的反序:
      'moT'   'yrreJ'   'skipS'     'ekyT'
   排序的结果为:
      ['Spike', 'Tyke', 'Tom', 'Jerry']
   请问如何用sorted进行排序

# 练习:
#   names = ['Tom', 'Jerry', 'Spike', 'Tyke']
#   排序的依据为字符串的反序:
#      'moT'   'yrreJ'   'skipS'     'ekyT'
#   排序的结果为:
#      ['Spike', 'Tyke', 'Tom', 'Jerry']
#   请问如何用sorted进行排序



def reverse_str(s):
    '''s绑定需要排序的可迭代对象提供的元素'''
    r = s[::-1]  # 把转原字符串
    print("要排序的元素:", s, '排序的依据是:', r)
    return r

names = ['Tom', 'Jerry', 'Spike', 'Tyke']

L = sorted(names, key=reverse_str)

print(L)  #  ['Spike', 'Tyke', 'Tom', 'Jerry']

递归函数 recursion Function
   故事:
     从前有座山,山上有座庙,庙里有个老和尚讲故事:
       从前有座山,山上有座庙,庙里有个老和尚讲故事:
         从前有座山,山上有座庙,庙里有个老和尚讲故事:

# recursion_story.py

def story():
    print("从前有座山, 山上有座庙,庙里有个老和尚讲故事:")
    story()

story()

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

  示例:
     # 函数直接调用自身
     def f():
         f()  # 调用自己
     f()

    # 函数间接调用自身
     def fa():
         fb()  # 调用另一个函数fb

    def fb():
         fa()  # 调用fa

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

递归的优缺点:
   优点:
     递归可以把问题简单化,让思路更为清晰,代码更为简洁
   缺点:
     递归因系统环境影响大,当递归深度太大时,可能会得到不可预知
     的结果
递归的两个阶段:
   递推阶段: 从原问题出发,按递归公式递推,从未知到已知,最终达到
        递归的终止条件
   回归阶段: 按递归终止条件求出结果,逆向逐步代入递归公式,回归
        原问题求解

递归函数的实现方法:
    先假设函数已经实现了原功能,再编写函数

示例见:
   recursion.py
# 递归求阶乘示例见:
   recursion_factorial.py

# recursion.py

def fx(n):
    print('递归进入第', n, '层')
    if n  == 3:
        return
    fx(n + 1)
    print('递归退出第', n, '层')

fx(1)
print("程序退出")

# recursion_factorial.py
#      1   (如果n为0)
#    /
# n!
#      n * (n-1)!  (如果n不为零时)

def myfac(n):
    if n == 0:  # 0! 为 1
        return 1
    else:
        return n * myfac(n-1)  # n! = n * (n-1)!

print(myfac(5))  # 120

练习:
   写一个递归求和函数:
     def mysum(n):
          ...
     此函数求 1 + 2 + 3 + 4 + ..... + n 的和

    print(mysum(100))  # 5050

# 练习:
#   写一个递归求和函数:
#     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

思考题:
   已知有五位朋友在一起
     第5个人说他比第4个人大2岁
     第4个人说他比第3个人大2岁
     第3个人说他比第2个人大2岁
     第2个人说他比第1个人大2岁
     第1个人说他10岁
   编写程序求:
     1) 算出第五个人几岁
     2) 算出第三个人几岁

# 思考题:
#   已知有五位朋友在一起
#     第5个人说他比第4个人大2岁
#     第4个人说他比第3个人大2岁
#     第3个人说他比第2个人大2岁
#     第2个人说他比第1个人大2岁
#     第1个人说他10岁
#   编写程序求:
#     1) 算出第五个人几岁
#     2) 算出第三个人几岁

def get_age(n):
    if n == 1:
        return 10
    return get_age(n - 1) + 2

print('第五个人', get_age(5), '岁')
print('第三个人', get_age(3), '岁')

闭包 closure
什么是闭包?
   闭包是指引用了此函数外部嵌套函数作用域的变量的函数

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

全局变量和局部变量的区别:
   全局变量:
     一直存在,谁都可以访问和修改
   局部变量:
     只是在函数调用时存在,只能在函数内部进行访问和修改

示例见:
   closure.py
   closure2.py
   closure3.py

# closure.py

# 用全局变量保存压岁钱

money = 1000  # 爸爸给函数的压岁钱

def child_buy(obj, m):
    global money
    if money > m:
        money -= m
        print('买', obj, '花了', m, '元,剩余',
              money,'元')
    else:
        print("买", obj, '失败')

child_buy("变形金刚", 200)
money = 0  # 钱被偷走了
child_buy('漫画三国', 100)
child_buy('手机', 1300)

# closure.py

# 用局部变量保存压岁钱(不附合逻辑)

def child_buy(obj, m):
    money = 1000  # 爸爸给函数的压岁钱
    if money > m:
        money -= m
        print('买', obj, '花了', m, '元,剩余',
              money,'元')
    else:
        print("买", obj, '失败')

child_buy("变形金刚", 200)
child_buy('漫画三国', 100)
child_buy('手机', 1300)

# closure.py

# 用外部嵌套函数内的变量保存压岁钱

def give_yasuiqian(money):
    def child_buy(obj, m):
        nonlocal money
        if money > m:
            money -= m
            print('买', obj, '花了', m, '元,剩余',
                money,'元')
        else:
            print("买", obj, '失败')
    return child_buy  # 返回内嵌函数的引用关系

cb = give_yasuiqian(1000)  # 给压岁钱1000

cb("变形金刚", 200)
cb('漫画三国', 100)
cb('手机', 1300)

闭包的注意事项:
   由于闭包会使得函数中的变量都被保存在内存中,内存消耗比较大,所
   以不能滥用闭包
闭包的应用示例见:
   closure_make_power.py

# closure_make_power.py

# 此示例示意闭包的应用

# 写一个求x的平方的函数
# def pow2(x):
#     return x**2
# 写一个求x的立方的函数
# def pow3(x):
#     return x**3

# 写一个求x的102次方的函数
# def pow102(x):
#     return x**102

# 写一个求x的150次方的函数
# def pow150(x):
#     return x**150

# 用闭包实现上述功能
def make_power(y):
    def fn(x):
        return x ** y  # y为外部嵌套函数的变量
    return fn

pow2 = make_power(2)
print('5的平方是:', pow2(5))
print('6的平方是:', pow2(6))
pow3 = make_power(3)
print('7的立方是:', pow3(7))
# ....
pow150 = make_power(150)
print(pow150(2))

小结:
   函数式编程:
     高阶函数:
       map, filter, sorted
  
   递归函数
   闭包

练习:
   1. 写程序算出1~20的阶乘的和,即:
     1!+2!+3!+4!+......+19!+20!

#   1. 写程序算出1~20的阶乘的和,即:
#     1!+2!+3!+4!+......+19!+20!

def myfac(x):
    if x == 0:
        return 1
    return x * myfac(x-1)

# 方法1
# s = 0
# for x in range(1, 21):
#     s += myfac(x)
# print('和是:', s)

# 方法2
print("和是:", sum(map(myfac, range(1, 21))))

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

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



L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20]

def print_list(lst, newline=False):
    for x in lst:
        if type(x) is list:  # 如果是列表,则按相同规则打印列表
            print_list(x)
        else:  # 如果是数字则直接打印
            print(x, end=' ')
    if newline:
        print()  # 换行

print_list(L, True)  # 3 5 8 10 13 14 ....


def sum_list(lst):
    s = 0
    for x in lst:
        if type(x) is list:
            s += sum_list(x)
        else:
            s += x
    return s

print(sum_list(L))  # 106

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

#   3. 改写之前的学生信息管理程序:
#     用两个函数来封装功能的代码块
#        函数1:  input_student()   # 返回学生信息字典的列表
#        函数2:  output_student(L)  # 打印学生信息的表格

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)   # 把d加入列表中L
    return L

def output_student(L):
    print("+---------------+----------+----------+")
    print("|     姓名      |   年龄   |   成绩   |")
    print("+---------------+----------+----------+")
    for d in L:
        name = d['name']
        age = str(d['age'])  # 转为字符串
        score = str(d['score'])  # 转为字符串
        print("|%s|%s|%s|" % (name.center(15),
                            age.center(10),
                            score.center(10)))
    print("+---------------+----------+----------+")

def delete_student(L):
    name = input("请输入要删除学生的姓名: ")
    i = 0  # i 代表列表的索引
    while i < len(L):
        d = L[i]  # d绑定字典
        if d['name'] == name:
            del L[i]
            print("删除", name, "成功!")
            break
    else:
        print("删除失败!")

def modify_student_score(L):
    pass


def output_by_score_desc(L):
    def get_score(d):
        return d['score']
    L2 = sorted(L, key=get_score, reverse=True)
    output_student(L2)

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

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

def output_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():
    infos = []  # 此列表用于保存学生数据
    while True:
        show_menu()
        s = input("请选择: ")
        if s == '1':
            infos += input_student()
        elif s == '2':
            output_student(infos)
        elif s == '3':
            delete_student(infos)
        elif s == '4':
            modify_student_score(infos)
        elif s == '5':
            output_by_score_desc(infos)
        elif s == '6':
            output_by_score_asc(infos)
        elif s == '7':
            output_by_age_desc(infos)
        elif s == '8':
            output_by_age_asc(infos)
        elif s == 'q':
            break

main()