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、文件操作
   
   trancate，截取前面
   read
    read(1) :无b，字符
    read(1) :有b，字节
   write
    str     ：无，字符串
    bytes   ：有，字节
   
   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)

　　

 

filter 方法的实现

 1 #filter 实现
 2 def myfilter(fuc,seq):
 3     new_li = []
 4     for i in seq:
 5         #print(i)
 6         ret = fuc(i)
 7         if ret:
 8             new_li.append(i)
 9     return new_li
10 def f1(x):
11     if x > 22:
12         return True
13     else:
14         return False
15 li = [11,22,33,44]
16 new=myfilter(f1,li)
17 print(new)
View Code

filter原理图见我的博客

http://www.cnblogs.com/liujianzuo888/articles/5475750.html

 

map方法实现

 

 1 # map 实现
 2 def mymap(fuc,seq):
 3     n_li = []
 4     for i in seq:
 5         n_i=fuc(i)
 6         n_li.append(n_i)
 7     # print(n_li)
 8     return n_li
 9 def f2(x):
10     return x+10
11 li = [11,22,33,44]
12 
13 ret = mymap(f2,li)
14 print(ret)
View Code

map原理图见我的博客

http://www.cnblogs.com/liujianzuo888/articles/5475750.html

 

三 冒泡算法

 

 

 1 #!/usr/bin/env python
 2 # _*_ coding:utf-8 _*_
 3 __author__ = 'liujianzuo'
 4 
 5 li = [33,2,10,1,11,99,88]
 6 
 7 print()
 8 #让 第一个元素跟第二个元素替换 需要一个中间值存储
 9 tmp = li[0]
10 li[0] = li[1]
11 li[1] = tmp
12 
13 for j in range(1,len(li)):
14     for i in range(len(li)-j):
15         if li[i]>li[i+1]:
16             tmp = li[i]
17             li[i] = li[i+1]
18             li[i+1] = tmp
 

　　

　　

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

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

1 li = [13, 22, 6, 99, 11]
2 
3 for m in range(4):     # 等价于 #for m in range(len(li)-1):
4     if li[m]> li[m+1]:
5         temp = li[m+1]
6         li[m+1] = li[m]
7         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
第二步
1 li = [13, 22, 6, 99, 11]
2 
3 for i in range(1,5):
4     for m in range(len(li)-i): 
5         if li[m] > li[m+1]:
6             temp = li[m+1]
7             li[m+1] = li[m]
8             li[m] = temp
第三步

选择排序

选择排序无疑是最简单直观的排序。它的工作原理如下。

步骤：

  1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
  2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  3. 以此类推，直到所有元素均排序完毕。
最大或最小从左向右排序 

li = [99,33,66,22,6,111,100,5,33]

for j in range(2,len(li)+1):
    for i in range(j-1,len(li)):
        if li[j-2] < li[i]:
            temp = li[j-2]
            li[j-2] = li[i]
            li[i] = temp

print(li)

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

print(li)

　　

 

四 递归

利用函数编写如下数列：

斐波那契数列指的是这样一个数列 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

1 def func(arg1,arg2):
2     if arg1 == 0:
3         print arg1, arg2
4     arg3 = arg1 + arg2
5     print arg3
6     func(arg2, arg3)
7 
8 func(0,1)

 

递归中的return返回值

 

 

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

 

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

 

 

 1 如下  n5 返回值 返回给其调用者  再返回给上一层调用者。  如果 n4 n3 n2 n1 其中一个不加return 则返回none
 2 def n5():
 3     return 5
 4 def n4():
 5     return n5()
 6 def n3():
 7     return n4()
 8 def n2():
 9     return n3()
10 def n1():
11     return  n2()
12 
13 ret1 = n1()
14 print(ret1)

 

总结： return 函数()  

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

函数返回值

 

递归返回值图理解、

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

 

 

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

 1 #!/usr/bin/env python
 2 # _*_ coding:utf-8 _*_
 3 __author__ = 'liujianzuo'
 4 
 5 def f(depth,arg1,arg2):
 6     if depth == 10:
 7         return arg1
 8     arg3 =arg1+arg2
 9     #print(arg1)
10     return f(depth+1,arg2,arg3)
11 #
12 # ret = f(1,0,1)
13 # print(ret)
14 def new(n):
15     if n == 0:
16         return 0
17     elif n == 1:
18         return 1
19     else:
20         return  new(n-1)+new(n-2)
21 
22 a=new(10)
23 print(a)
View Code

 

posted @ 2016-05-12 13:02  众里寻，阑珊处  阅读(519)  评论(0)  编辑  收藏  举报
返回顶部