python基础-5 冒泡排序、递归

上节总结

 一、上节内容补充回顾
  1、lambda
   func = lambda x,y: 9+x
   参数：  x,y
   函数体：9+x  ==》 return 9+x
   func: 函数名

   def func(x,y):
    return x + 9
   def func(x,y):
    return x + 9

   func = lambda x,y: 9+x

   扩展：函数名可以当做参数传递
     函数名() ==》 执行函数
     函数名 ==》 代指函数

  2、内置
   xxx
  3、open文件操作
   open()
   1、文件路径
   2、模式
    基本操作：
     r，只读
     w，只写（先清空）
     x，不存在，创建，存在，报错： 只写
     a，追加，只写,不可读
    二进制
     rb
     wb
     xb
     ab
    +
     r+，读写：
       读，0开始读取
       写，先读了，往最后追加。
             先读，最后追加
             主动seek，写从当前指针向后写
         ==》

     w+，读写
     x+，读写
     a+，读写
       读，最后位置读取
       写，
        最后追加
        主动seek，还是最后追加

    r+ 最常用
   3、文件操作

    truncate，截取前面
    read
     read(1) :无b，字符，取决于打开的方式
     read(1) :有b，字节，
    write
     str     ：无b，字符串
     bytes   ：有b，字节

    readline
     只读取一行

    readlines:
     [“第一行”, "第二行"]

    xrealines:  2.7
     for line in f.xrealines():
      line

    f = open()
    for i in f:
     print(i)

    flush
     强行刷入硬盘

    close

    tell()  获取指针位置
    seek()  跳转到某个位置

   4、 whth open(xx) as f:
     print

   5、with open(xx) as f1 ,open(xx) as f2:

 查看总结内容

函数作为参数传入另一个函数

 # 2 函数参数
 def f1():
     return "F1"
 def f2(arg):
     arg()
     return 'F2'

 # 变量 x =123
 # 函数名 f1 = 对应def f1 内存地址
 # 函数名 f2 = 对应def f2 内存地址
 # print(f1)

 # 执行f2函数，f1当传参
 f2(f1)

f1，代指这个函数名，没有执行。这时f1就是一个变量，可以当作参数传入另外一个函数

f1()，去执行这个函数。

filter 方法的实现

 def myfilter(func, args):
     #func，函数名，func=func_t
     result = []
     for i in args:
         if func(i):#执行接收的函数，并获取返回值
             result.append(i)
     return result

 def func_t(x):
     if x > 22:
         return True
     else:
         return False

 r = myfilter(func_t, [11, 22, 33, 44, 55])
 print(r)

 C:\Python35\python3.exe E:/py/55/learn-python/oldboy/5/myFilter.py
 [33, 44, 55]

map方法实现

 def mymap(func, args):
     # func=>f1函数
     # args=>[11,22,33,44,55]
     result = []
     for i in args:
         result.append(func(i))  # func(11)=》f1(11)
     return result

 def f1(x):
     return x + 100

 r = mymap(f1, [11, 22, 33, 44, 55])
 print(r)

 C:\Python35\python3.exe E:/py/55/learn-python/oldboy/5/my_map.py
 [111, 122, 133, 144, 155]

1、冒泡排序

 #互换两个参数值
 a1 = 123
 a2 = 456

 #引入temp中间值
 # # temp = a1
 # # a1 = a2
 # # a2 = temp
 # # print(a1, a2)

 #不引入temp
 a1 = a1 + a2 #先将两个数的和赋值给其中一个
 a2 = a1 - a2  #用和减去自己，就是新的值，a1
 a1 = a1 - a2  #在用和减去新的另外一个数，就变换了。a2
 print(a1, a2)

需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序

思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

 li = [13, 22, 6, 99, 11]

 for m in range(4):     # 等价于 #for m in range(len(li)-1):
     if li[m]> li[m+1]:
         temp = li[m+1]
         li[m+1] = li[m]
         li[m] = temp

 第一步

 li = [13, 22, 6, 99, 11]

 for m in range(4):     # 等价于 #for m in range(len(li)-1):
     if li[m]> li[m+1]:
         temp = li[m+1]
         li[m+1] = li[m]
         li[m] = temp

 for m in range(3):     # 等价于 #for m in range(len(li)-2):
     if li[m]> li[m+1]:
         temp = li[m+1]
         li[m+1] = li[m]
         li[m] = temp

 for m in range(2):     # 等价于 #for m in range(len(li)-3):
     if li[m]> li[m+1]:
         temp = li[m+1]
         li[m+1] = li[m]
         li[m] = temp

 for m in range(1):     # 等价于 #for m in range(len(li)-4):
     if li[m]> li[m+1]:
         temp = li[m+1]
         li[m+1] = li[m]
         li[m] = temp
 print li

 第二步

 li = [13, 22, 6, 99, 11]

 for i in range(1,5):
     for m in range(len(li)-i):
         if li[m] > li[m+1]:
             temp = li[m+1]
             li[m+1] = li[m]
             li[m] = temp

 第三步

 #冒泡排序练习
 li = [1, 22, 11, 55, 23, 33, 12, 56, 4, 7]
 le = len(li)
 while le > 0:
     for i in range(le - 1):
         if li[i] > li[i + 1]:
             li[i] = li[i] + li[i + 1]
             li[i + 1] = li[i] - li[i + 1]
             li[i] = li[i] - li[i + 1]
     le -= 1
 print(li)

2、递归

利用函数编写如下数列：

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

 def func(arg1,arg2):
     if arg1 == 0:
         print arg1, arg2
     arg3 = arg1 + arg2
     print arg3
     func(arg2, arg3)

 func(0,1)

递归中的return返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

以上要点中，比较重要有参数和返回值：

 如下  n5 返回值 返回给其调用者  再返回给上一层调用者。  如果 n4 n3 n2 n1 其中一个不加return 则返回none
 def n5():
     return 5
 def n4():
     return n5()
 def n3():
     return n4()
 def n2():
     return n3()
 def n1():
     return  n2()

 ret1 = n1()
 print(ret1)

总结： return 函数()

　　先调用函数，然后在return将获取的返回这返回给调用这个函数的变量

函数返回值

递归返回值图理解、

同上图类似，只不过函数名为同一个了

练习  利用递归 打印 斐波那契数列第10个数

 def func(d, a1, a2):
     print(a1,a2)
     if d == 10:
         return a1
     a3 = a1 + a2
     return func(d+1, a2, a3)

 ret = func(1, 0, 1)
 print(ret)