第十三天

今日内容

一、三元表达式

1.1便利双分支表达（if,elif)

  例1：
        x = 11 y = 22
                （判断的条件）
        res = x if x >y elif y
     (条件成功返回的值） （条件不成功返回的值）
        print(res)

二、生成式

2.1列表生成式

  例1：创建一个0-9的列表
      for循环：
        l = []
        for i in range(10)
            l.append(i)
        print(l)
      
        列表生成式：
        l = [i for i in range(10)]
  
  例2：在0-9的列表中只取大于5的数字放进列表
      for循环：
        l = []
        for i in range(10):
          if i > 5:
              l.append(i)
        print(l)

       列表生成式：
        l = [i for i in range(10) if i>5]
        print(l)

  例3：往列表中名字加上后缀
        for循环：
        names = ["lxx","hxx","wxx","lili"]
        l = []
        for name in names:
            l.append(name+"_sb"]
        print(l)

        列表生成式：
        l = [name+"_sb" for name in names]
        print(l)

  例4：按条件过滤出列表内容
        names = ["egon","lxx_sb","hxx_sb","wxx_sb"]
        res = [name for name in names if name.endswith("sb")]
        print(res)

2.2字典生成式

  模板：
     例1：
      res = {i:i**2 for i in range(5)}
      print(res)

     例2：
      items = [("k1",111),("k2",222),("k3",333)]
      print(dict(items))
      print({k:v for k,v in items})

2.3集合生成式

  模板：
      res = {i for i in range(5)}
      print(res)

2.4生成器表达式

  模板：
      res = (i for i in range(3))     # 创建一个生成器
      print(next(res))
      print(next(res))
      print(next(res))

  例1：当文件很大时计算文件中字符的个数
      with open("a.txt",mode="rt",encoding="utf-8") as f:
        res = sum（len(line) for line in f)  #sum:将列表中的数字相加起来
        print(res)

三、函数递归

3.1函数的递归调用

  解释：在调用一个函数的内部又调用自己，所以递归调用的本质就是一个循环的过程
  例1：不能无限循环，当递归深度达到1000层时会自动停止，因为如果无限循环会生成无数个内存空间让电脑死机。
      def func():
        print("func")
        func()
      func()

  ps:如何让递归深度增加（深度越高，风险越大）
      import sys
      sys.setrecursionlimit(2000)
      print(sys.getrecursionlimit())

      大前提：递归一定要在某一层结束
      递归的两个阶段：
        1、回溯：往下一层一层挖井
        2、递推：往上一层一层返回
        例1：推断age(5)的值
          def age(n):
              if n == 1:
                return 18
              return age(n-1) + 10
          res = age(5)
          print(res)

        例2：取出列表中所有的数字
          nums = [1,[2,[3,[4,[5,[6]]]]]]
          def get(l):
                for num in l:
                  if type(num) is list:
                    get(num)
                  else:
                    print(num)
          get(nums)

        例3：推断目标数字是否在列表中（二分法取值）
          nums = [-3,-2,-1,0,1,3,4,5,7,19]
          find_num = 2
          def find(nums,find_num):
            if len(nums) == 0:
              print("not num")
              return
            mid_index = len(nums) // 2
            if find_num > num[mid_dinex]:
                    find(nums[mid_index+1:],find_num)
            elif find_num < nums[mid_index]:
                    find(nums[:mid_index],find_num)
            else:
              print("get num")
          find(nums,find_num)

四、匿名函数

匿名函数的定义：

  没有名字的函数
  例1：算两个值的合
      有名函数：
        def f(x,y):
            return x+y
        f(x,y)
      匿名函数：lambda
        lambda x,y:x+y   #匿名函数的定义
        
  例2：取出字典中薪资最高的人的名字（max)
        salaries = {
                    "egon":3000,
                    "tom":10000,
                    "zxx":1000
                    }
        print(max(salaries,key=lambda k:salaries[k]))  #取出字典中薪资最高人的名字
        print(min(salaries,key=lambda k:salaries[k]))  #取出字典中薪资最低人的名字
        print(sorted(salaries,key=lambda k:salaries[k]))  #以薪资从低到高的人名排序
        print(sorted(salaries,key=lambda k:salaries[k],reverse=True))  #以薪资从高到低的人名排序

五、匿名函数（了解）

5.1map

  把一个列表通过某个条件变成一个迭代器列表
  将下列表中所有元素加上"_sb"为后缀
  names = ["lxx","hxx","wxx","lili"]
  列表生成式：
  l = [name + "_sb" for name in names]    #换成小括号则列表变成迭代器
  map方式：
  res = map(lambda name:name + "sb" ,naems)
  print(list(res))

5.2filter

  把列表通过某种条件过滤成迭代器
  将下列表中后缀为sb的元素过滤出来
  names = ["lxx_sb","egon","wxx_sb","lili_sb"]
  列表生成式：
  print([name for name in names if name.endwith("sb")])
  filter方式
  res = filter(lambda name:name.endswith("sb"),names)

5.3reduce

  将列表里的值合并起来
  from functools import reduce
  res = reduce(lambda x,y:x+y,[1,2,3])
  print(res)

六、面向过程编程

  面向过程编程：核心是“过程”二字，过程就是解决问题的步骤，即先干啥，后干啥，再干啥，所以基于该思想编写程序就好比设计一条一条的流水线。
  优点：复杂的问题流程化，进而简单化
  缺点：牵一发而动全身，扩展性差