三元表达式、递归、二分法

一，三元表达式

　　1，语法格式：条件成立时要返回值 if 条件 else  条件不成立返回的值，

　　2，应用：

 1 原代码：
 2 def max2(x,y):
 3     if x > y:
 4         return x
 5     else:
 6         return y
 7 
 8 res = max2(1,2)
 9 改进后：
10 x=1
11 y=2
12 res = x if x > y else y # 三元表达式

　　3，列表生成式，理论上后面可以添加多个判断条件，但是不建议，因为可读性会边很差

1 原代码：
2 egg_list=[]
3 for i in range(10):
4     egg_list.append('鸡蛋%s' %i)
5 改进后：
6 egg_list=['鸡蛋%s' %i for i in range(10)]

　　4，字典生成器

1 l=['a','b','c']
2 s={i:None for i in l}
3 print(s)

　　5，集合生成器

1 l=['a','b','c']
2 s={i for i in l}
3 print(s,type(s))

　　6，生成器表达式（没有元组生成器）

1 l=['a','b','c']
2 s=(i for i in l)
3 print(next(s))
4 print(type(s))
5 *************
6 a
7 <class 'generator'>

二，递归

　　1，自己调用自己 1 def f1(): 2 print('from f1') 3 f1() 4 f1() 

　　　　　　　　　　　　　　

 　　2，两个函数互相调用

1 def f1():
2     print('from f1')
3     f2()
4 
5 def f2():
6     print('from f2')
7     f1()
8 
9 f1()

　　　　　　　　　　　　　　　　　　　　

　　3，调用停止方法，return

1 def fu1(i):
2     print("Hello")
3     i+=1
4     if i>5:
5         return 
6     fu1(i)
7 fu1()

 　　4，回溯与递推

　　回溯：就是打开一个个函数的过程

　　递推：条件满足后关闭一个个函数的过程

　　5，应用

1 items=[[1,2],3,[4,[5,[6,7]]]]
2 def foo(items):
3     for i in items:
4         if isinstance(i,list): #满足未遍历完items以及if判断成立的条件时，一直进行递归调用
5             foo(i) 
6         else:
7             print(i,end=' ')
8 
9 foo(items) #打印结果1 2 3 4 5 6 7

 三，二分法

　　将数据一分为二，与需要查找的值进行对比，直至找到结果

四，面向过程

　　​ ”面向过程“核心是“过程”二字，“过程”指的是解决问题的步骤，即先干什么再干什么......，基于面向过程开发程序就好比在设计一条流水线，是一种机械式的思维方式，这正好契合计算机的运行原理：任何程序的执行最终都需要转换成cpu的指令流水按过程调度执行，即无论采用什么语言、无论依据何种编程范式设计出的程序，最终的执行都是过程式的。

　　优点：复杂的问题流程化、进而简单话

　　缺点：扩展性非常差

　　场景解析：

　　　　1，不是所有软件都需要频繁迭代，比如编写脚本

　　　　2，即使一个软件需要频繁迭代，也不代表这个软件所有部分都需要迭代

五，函数式编程思想

　　函数式编程并非用函数编程这么简单，而是将计算机的运算视为数学意义上的运算，比起面向过程，函数式更加注重的是执行结果而非执行的过程，代表语言有：Haskell、Erlang。

　　函数式思想整体上是与python的思想不符的，但是部分是符合的。如lambda，map，reduce，filter。

　　1，匿名函数，就是没有名字的函数，

 1 有名函数： 2 def fu1(x,y): 3 return x+y 4 转化为匿名函数 5 lambda x,y:x+y 

　　　　应用方式：

  • 方式一： 直接调用res=(lambda x,y,z:x+y+z)(1,2,3) 
  • 方式二： 加一个名字（一般不会用）1 func=lambda x,y,z:x+y+z # “匿名”的本质就是要没有名字，所以此处为匿名函数指定名字是没有意义的 2 res=func(1,2,3) 
  • 方式三：与其他函数配合（匿名函数没有名字，就相当于没有变量名的变量值，所以很容易就被回收了） 
     1 salaries={
 2     'siry':3000,
 3     'tom':7000,
 4     'lili':10000,
 5     'jack':2000
 6 }
 7 找出最少工资的人：
 8 >>> max(salaries,key=lambda k:salaries[k]) 
 9 'lili'
10 # 原理同上
11 >>> min(salaries,key=lambda k:salaries[k])
12 'jack'

六，map、reduce、filter

  • map， 
     1 array=[1,2,3,4,5]
 2 
 3 要求一：对array的每个元素做平方处理，可以使用map函数
 4 
 5 map函数可以接收两个参数，一个是函数，另外一个是可迭代对象，具体用法如下
 6 
 7 >>> max(salaries,key=lambda k:salaries[k]) 
 8 'lili'
 9 # 原理同上
10 >>> min(salaries,key=lambda k:salaries[k])
11 'jack'
12 
13 解析：map会依次迭代array，得到的值依次传给匿名函数（也可以是有名函数），而map函数得到的结果仍然是迭代器。
14 
15 >>> list(res) #使用list可以依次迭代res，取得的值作为列表元素
16 [1, 4, 9, 16, 25]

     

  • reduce， 
     1 reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值
 2 
 3 # reduce在python2中是内置函数，在python3中则被集成到模块functools中，需要导入才能使用
 4 >>> from functools import reduce 
 5 >>> res=reduce(lambda x,y:x+y,array)
 6 >>> res
 7 15
 8 解析：
 9 
10 1 没有初始值，reduce函数会先迭代一次array得到的值作为初始值，作为第一个值数传给x，然后继续迭代一次array得到的值作为第二个值传给y，运算的结果为3
11 
12 2 将上一次reduce运算的结果作为第一个值传给x，然后迭代一次array得到的结果作为第二个值传给y，依次类推，知道迭代完array的所有元素，得到最终的结果15
13 
14 也可以为reduce指定初始值
15 
16 >>> res=reduce(lambda x,y:x+y,array,100)
>>> res
17 115

     

  • filter， 
    1 对array进行过滤操作，这就用到了filter函数，比如过滤出大于3的元素
2 
3 >>> res=filter(lambda x:x>3,array)
4 解析：filter函数会依次迭代array，得到的值依次传给匿名函数，如果匿名函数的返回值为真，则过滤出该元素，而filter函数得到的结果仍然是迭代器。
5 
6 >>> list(res) 
7 [4, 5]

     

posted on 2024-02-07 00:18  我才是最帅的那个男人  阅读(10)  评论(0)    收藏  举报

导航