网站 › 『编程语言区』 › 【Python】人工智能全栈工程师（0基础到精通）教程 第十八课

ParisGabriel 发表于 2018-7-17 00:47

【Python】人工智能全栈工程师（0基础到精通）教程 第十八课

本帖最后由 ParisGabriel 于 2018-7-17 00:57 编辑





ParisGabriel



感谢 大家的支持                                全部课程 原文地址 ：                                                                           http://www.cnblogs.com/ParisGabriel/tag/Python/
　https://images2018.cnblogs.com/blog/1430617/201807/1430617-20180709225751471-608583048.png                                                       https://attach.52pojie.cn/forum/201807/10/010120qq61dzx7sozu9s9s.png

　                   每天坚持手写一天一篇 点个订阅吧决定坚持几年 全栈工程师（包含：python、爬虫、Web、人工智能、h5等）       讲完接着 java、黑客攻防 、渗透、                                                               易语言（比较简单学完python基本就会了）、等等到时候再说....IT无止境！   灰常感谢    当个死粉也阔以https://static.52pojie.cn/static/image/smiley/default/mad.gifhttps://static.52pojie.cn/static/image/smiley/default/mad.gif　　　　　　　　　　　　　　　　　　　　　　
                                                                              Python人工智能从入门到精通



函数式编程：
　　是指用一系列函数解决问题
　　每一个函数完成细小的功能，一系列函数的任意组合可以完成
　　大问题
　　函数仅接受输入并产生输入，不包含任何影响输出的内部 状态
函数的可重用性：
　　如果一个函数的输入参数一定，则返回结果必须一定
　　的函数称为可重用函数　　可重入和不可重入就是访问除局部变量以外的变量
函数式编程要求：
　　def 创建函数最好不要访问局部作用域以外的变量，这样可以保证
　　结果的唯一性（可重入性）
高阶函数 high order function：
　　满足下列条件之一的就是高阶函数
　　1.函数接受一个或多个函数作用参数传入
　　1.函数返回一个函数
内建高阶函数：
　　map，filter，sortedmap(func, *iterables)：
　　用函数和对可迭代对象中的每一个元素作为参数计算出新的可迭代对象,
　　当最短的一个可迭代对象不再提供数据时此可迭代对象生成结束

filter(function, iterable)：
　　筛选可迭代对象iterable中的数据,返回一个可迭代器对象，此可迭代对象
　　将对iterable进行筛选.函数function 将对iterable中的每个元素进行求值，
　　返回False则将此数据丢弃，返回True，则保留此数据
sorted(iterable, key=None, reverse=False)：
　　将原可迭代对象的数据进行排序，生成排序后的列表iterable 可迭代对象
　　key 函数是用来提供一个值,这个值将作为排序的依据reverse 标志用来设
　　置是否降序排序
返回可迭代对象：
　　range（）
　　map（）
　　filter（）
　　reverse（）
递归函数;
　　函数直接调用或间接的调用自身
　　直接调用自己：
　　　　def f（）：
　　　　    f（）
　　间接调用自己：
　　　　def fa（）：
　　　　    fb（）
　　　　def fb（）：
　　 　　 fa（）
https://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716221725720-499329058.pnghttps://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716221742118-135226500.pnghttps://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716221754551-92783365.pnghttps://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716221805323-131418154.pnghttps://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716221821351-1849857050.pnghttps://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716221834360-2063106846.png　　递归一定要控制递归的层数，当符合条件时要终止递归
　　几乎所有的递归都能用while循环来代替
递归特点：
　　优点：
　　　　递归吧问题简单化，让思路更清晰，代码更简洁
　　缺点：
　　　　递归因系统环境影响大，当递归深时，可能会得到不可预知的结果
递推阶段：
　　从原问题出发，按递归公式递推从未知到已知，最终打到递归的终止条件
　　回归阶段
　　按递归终止条件求出结果，逆向逐步代入递归公式
　　回归到原问题求解
闭包 closure：
　　闭包是引用了此函数外部的变量函数
　　说明：
　　　　本质上，闭包是将内部嵌套和函数外部的执行环境绑定在一起的对象
　　条件：
　　　　1.必须有一个内嵌函数
　　　　2.内嵌函数必须引用外部函数中的变量
　　　　3.处部函数返回值必须是内嵌函数   


函数式编程就是把一些小功能封装成函数 提高代码的可重用性 可读性 可维护性 而且可以重复变量


可重用函数就是自身内部完成一系列的功能不与外界干扰的函数
为了保证函数的可重用性虽然可以用外界变量 但是尽量不要用
高阶函数
就是形参和返回值只要有一个是函数的函数


递归：
这个要好好说一下了 说实话 对于初中没念完的我学的全部都是高数真的是难
但那有什么办法呢 只能是慢慢来 不过我要非常感谢一个小姐姐就是刘笑笑（ 0^0 不知道你看不看 嘻嘻）
不厌其烦的给我讲了好几个小时我才绕过来我个人感觉这个东西挺绕的


就拿5的阶乘来说吧 5 * 4 * 3 * 2 * 1
递归就是从5的阶乘五的阶乘不知道 是个未知数但是5到1是知道的54321嘛对吧
1的阶乘也是知道的等于1
5的阶乘就等于5 * 5 - 1 * 5-2 * 5-3 * 5 - 4
用一个递归函数来实现就是
def fact（n）：            第一次执行函数n = 5                     |       第二次执行这里n就变成了4                | 第三次执行这里n就变成了3
if n == 1：               n != 1    不执行
   return 1                                                          |       n != 1    不执行                        | n != 1    不执行
return n * fact（n - 1）   执行这一步 其实这里有个else
                           省略了 可以省略这里n = 5                |       条件不成立 继续执行fact函数 让函数的形参| 条件不成立 继续执行fact函数 让函数的形参
                           5 * 函数fact（n - 1） 这里代表上面if
                           条件不成立 继续执行fact函数 让函数的形参|       继续减1后继续执行                     | 继续减1后继续执行
                           减1后继续执行
print（fact（5））




直到 n = 1的时候   n == 1那么条件成立
条件成立 然后开始return（这里是关键 return是什么呢？
return就是让函数结束执行并且返回一个值说白了就是让函数变成值 变成数据
之前的函数直接消失不再执行 并且返回的值 只会返回到调用它的函数的位置（函数变量））
当一次return 的时候 fact（n）此时n是等于1的 对吧 此时n == 1 条件成立 返回1 结束释放 函数fact（1）（最底层函数释放）
返回1 就是等于 fact（n - 1） （这里这个函数直接变成了值：1） 上面的fact（n）n = 1 的时候 1哪来的就是 fact（n - 1）来的
return n * fact（n - 1） 这里的n 是相等的 那么 2 * 1 然后利用这里的return继续返回 就等于 fact（n）这个函数 这时n = 2 （但是这个函数的返回值是2 * 1）
fact（n）这个函数释放 返回到调用他的函数 return n * fact（n - 1）这里2怎么来的n - 1 = 2同样的道理 这里的两个n都等于3
3 * fact（3 - 1）但是呢这里的 fact（3 - 1）函数已经被释放了并return返回值那么fact（3 - 1）等同于 2 * 1 这里就是 3 * 2 *1 然后利用这里的return返回
然后这样依次类推 回到最开始调用的地方 并return返回产生结果得到的就是5 * 4 * 3 * 2 * 1系统会自动计算这就是我们想要的结果了


其实递归是两个过程就是先递后归 先下楼在上楼 把所有的东西都推理出来以后再依次归递运算就去楼下搬东西 每层都有你要先去1楼看一下
有多少东西 能不能一次搬完路过的几层你不可能带到一楼再带上去吧
其实这些东西 用for也好还是while也好都是分分钟的事但是递归的方式逻辑和思维更加清晰 （噗 反正我觉得不怎么好但是感觉比较好修改和维护）
还有就是递归一定要设置返回条件 不然就是死循环（成语接龙：为所欲为，为所欲为，为所欲为，为你妈逼，逼上梁山， 山穷水尽， 尽力而为， 为所欲为， 为所欲为...... ）
计算机能接受的最大递归层次也就1000左右 取决于你的电脑配置


其实闭包就比较简单了 就是 函数内部变量引用你外部的变量
这里的外部指的是两个函数之间 当外函数释放时候 内函数的变量不被释放 保持原绑定值




额 这个NB 吹的有点长了.........还有好多题没做又要加班到一天了每天要敲16小时以上的键盘0_0





练习:names = ['Tom', 'Jerry', 'Spike', 'Tyke']排序的依据为字符串的反序:         'moT'   yrreJ    ekipS    ekyT结果:    ['Spike', 'Tyke', 'Tom', 'Jerry']答案：
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
def name(s):
    return s[::-1]
print(sorted(names, key=name))
https://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716235626031-18172697.png # 练习：#   1.　已知五位朋友在一起#   第五位朋友比第四位朋友大2岁#   第四位朋友比第三位朋友大2岁#   第三位朋友比第二位朋友大2岁#   第二位朋友比第一位朋友大2岁#   第一位朋友说它10岁#   写程序打印出第五位朋友　和第三位朋友　的年龄 答案：
def myage(n):
    if n == 1:
      return 10
    return 2 + myage(n - 1)
print(myage(5))
print(myage(3))
https://images2018.cnblogs.com/blog/1430617/201807/1430617-20180716235638053-1484730040.png
4 实现带有界面的学生信息管理系统
程序启动时先弹出操作菜单:
+-------------------------+
| 1) 添加学生信息 |
| 2) 显示学生信息 |
| 3) 删除学生信息 |
| 4) 修改学生成绩 |
| q) 退出 |
+-------------------------+
请选择: 1
要求 ：
每个选择都要有一个函数来实现

def student():
    for a in range(1, 8, 2):
      x = "*" * a
      print(x.center(9), x.center(10), x.center(10), x.center(9))
    else:
      for y in range(1, 4 + 1):
            c = "*"
            if 4 >= 10:
                c = "***"
            print(c.center(9), c.center(10), c.center(10), c.center(9))
    print("^^^^^^^^^^^^^ System menu ^^^^^^^^^^^^^")
    print("---------------------------------------")
    print("    1):    Add Student information   ")
    print("---------------------------------------")
    print("    2):    print Student information   ")
    print("---------------------------------------")
    print("    3):    delete Student information")
    print("---------------------------------------")
    print("    4):    revamp Student information")
    print("---------------------------------------")
    print("   please input number 1~4 select    ")
    print("---------------------------------------")
    print("      input :(Q)Exit procedure       ")
    print("---------------------------------------")
# 创建输出函数：perform完成


# 创建输入函数：input_student开始　　　　　封装信息输入


def input_student():
    L = []
    print("--------Student information enty--------")
    while True:
      name = input("please input name:")
      if name == "":
            q = input("operation succeed! return y　/　n　:")
            if q == "y":
                break
            else:
                input_student()
      age = input("please input age:")
      score = input("please input score:")
      d = {}
      d = {"name": name, "age": age, "score": score}
      print("+---------------+----------+----------+")
      name = d["name"].center(15)
      age = d["age"].center(10)
      score = d["score"].center(10)
      print('''|%s|%s|%s|''' % (name, age, score))
      print("+---------------+----------+----------+")
      print("-----Not input Enter be no revamp!-----")
      L.append(d)
    return L
# 创建输入函数：input_student完成

# 创建输出函数：output_student开始　　　封装列表打印


def output_student(lst):
    print("-------Student information sheet-------")
    print("+---------------+----------+----------+")
    print("|      Name   |    Age   |   Score|")
    print("+---------------+----------+----------+")
    for d in lst:
      name = d["name"].center(15)
      age = d["age"].center(10)
      score = d["score"].center(10)
      print('''|%s|%s|%s|''' % (name, age, score))
      print("+---------------+----------+----------+")
    q = input("operation succeed! return y　/　n　:")
    if q == "y":
      pass
    else:
      output_student()
# 创建输出函数：output_student完成

# 创建输出函数：delete_student开始　　封装删除信息


def delete_student(lst):
    name = input("please input name delete:")
    for x in lst:
      if x["name"] == name:
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = x["age"].center(10)
            score = x["score"].center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            delet = input("whether delete (y:yes/y:no):")
            if delet == "y":
                lst.remove(x)
    q = input("operation succeed! return y　/　n　:")
    if q == "y":
      pass
    else:
      delete_student()
# 创建输出函数：delete_student完成

# 创建输出函数：revamp_student()开始　　　封装更改信息


def revamp_student(lst):
    name = input("please input name revamp:")
    for x in lst:
      if x["name"] == name:
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = x["age"].center(10)
            score = x["score"].center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            print("-----not input Enter be no revamp!-----")
            rage = input("please input age revamp:")
            rscore = input("please input score revamp:")
            if rage != "":
                x["age"] = rage
            if rscore != "":
                x["score"] = rscore
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = x["age"].center(10)
            score = x["score"].center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            print("-----------revamp perform!------------")
      else:
            print("None Error")
    q = input("operation succeed! return y　/　n　:")
    if q == "y":
      pass
    else:
      revamp_student()
# 创建输出函数：revamp_student()完成

# 创建输出函数：System_menu()开始　　　　临时封装系统


def System_menu():
    L = []
    while True:
      student()
      select = input("            please input:")
      if select == '1':
            L += input_student()
      elif select == '2':
            output_student(L)
      elif select == '3':
            delete_student(L)
      elif select == '4':
            revamp_student(L)
      elif select == 'q':
            break
# 创建输出函数：System_menu()完成　　　　临时封装系统


# 运行
System_menu()
https://images2018.cnblogs.com/blog/1430617/201807/1430617-20180717003913896-432419870.pnghttps://images2018.cnblogs.com/blog/1430617/201807/1430617-20180717003934735-1919282791.png https://images2018.cnblogs.com/blog/1430617/201807/1430617-20180717003940546-365061590.png

敛弈逆袭 发表于 2018-7-17 01:04

大哥你好像发了两个一样的吧

chen4321 发表于 2018-7-17 07:02

谢谢分享

wdlcshpzjfxx 发表于 2018-7-17 07:41

太复杂了呀

WEI995 发表于 2018-7-17 08:42

大哥发的频率好高，支持

axllen 发表于 2018-7-17 08:53

谢谢分享

villyx 发表于 2018-7-17 09:30

好贴，谢谢楼主！

bollwarm 发表于 2018-7-17 09:33

python也就掉个接口，还全栈，全栈的的用c搞

凉99 发表于 2018-7-17 09:39

支持一下

小黑LLB 发表于 2019-2-3 17:02

谢谢分享 支持一下吧{:1_921:}

查看完整版本: 【Python】人工智能全栈工程师（0基础到精通）教程 第十八课