《think in python》学习-6

think in python

有返回函数

我们使用过的内置函数中，有一部分会返回结果，比如 math的

返回值

我们写一个有返回值的函数，计算给定半径的圆的面积，例如这个：

def area(raduis):
    temp = math.pi * radius*2
    return temp

当然可以简化这个版本

def area(raduis):
    return math.pi * radius * 2   #省去temp变量这个步骤

有时候会有不同分支，根据不同分支返回不同的结果：

def absoulte_value(x):
    if x<0:
        return -x
    else:
        return x

增量开发

每次只增加和测试一小部分代码，来避免长时间的调试过程

一个增量开发的示例(查找2点之间的距离，给定坐标 x1,y1 和 x2,y2)：

# 第一步可以点定义函数形参以及返回值
def distance(x1,y1,x2,y2):
    return 0.0
#第二步 可以开始计算2个点之间距离差了
def distance(x1,y1,x2,y2):
    dx = x2-x1
    dy = y2-y2
    print dx
    print dy
    return 0.0
#第三步 计算dx dy的平方
def distance(x1,y1,x2,y2):
    dx = x2-x1
    dy = y2-y2
    dsquared = dx**2+dy**2
    print dsquared
    return 0.0
#第四步 可以返回结果了
def distance(x1,y1,x2,y2):
    dx = x2-x1
    dy = y2-y2
    dsquared = dx**2+dy**2
    result = math.sqrt( dsquared)
    return result

这种开发过程的关键点是:

1. 以一个可以正确运行的程序开始，每次只做小的增量修改，如果在任意时刻发现错误，你都应当知道错误在哪里
2. 使用临时变量保存计算的中间结果，这样你可以显示和检查他们
3. 一旦整个程序完成，你可能会想要删除掉某些脚手架代码或者把多个语句综合到一个复杂表达式中，但只在不会增加代码阅读的难度时才应该那么做

组合

在函数中可以调用其他函数。这个能力被称为组合

我们写个函数，接收2个点，圆心和圆周上的一点，计算圆的面积， 这里用到组合以前的函数。

def distance(x1,y1,x2,y2):
    dx = x2-x1
    dy = y2-y2
    dsquared = dx**2+dy**2
    result = math.sqrt( dsquared)
    return result
def area(raduis):
    return math.pi * radius * 2 

def circle_area(xc,yc,xp,yp):
    radius = distance(sx,yc,xp,yp)
    return area(radius)

布尔函数

返回布尔值

def is_divisible(x,y):
    if x%y==0:
        return True
    else :
        return False

递归

阶乘函数可以通过return值和递归自己 来完成任务。

def factorial(n):
    if n==0:
        return 1
    else:
        recurse = factorial(n-1)
        result = n*recurse
        return result

另一个是 斐波那契数列：

def fibonacci(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    else:
        return fibonacci(n-1)+fibonacci(n-2)

检查类型

如果不检查传入参数的类型，很多时候会让程序报错

如果我们给factorial(1.5)这样执行，那么会报错。

我们有2个方法：

1. 泛化函数，使之能正确处理浮点数
2. 检查阐述类型，类型不匹配的返回None

   def factorial2(n):
       if not isinstance(n,int):
           print "非整数"
           return None
       elif n<0:
           print "不能为负数"
           return None
       elif n==0:
           return 1
       else:
           return n*factorial2(n-1)
   

调试

给函数添加print 往往能帮我们调试很多问题

例子：

def debug_factorial(n):
    space = ' '*(4*n)
    print space, "factorial",n
    if n==0:
        print space, "returning 1"
        return 1
    else:
        recurse = debug_factorial(n-1)
        result = n*recurse
        print space, "returning",result
        return result

练习

1. 写一个compare函数，如果x>y 返回1，如果x==y返回0 ,如果x<y 返回-1

   def compare(x,y):
       if x>y:
           return 1
       elif x==y:
           return 0
       else:
           return -1
   
   

2. 使用增量开发来编写一个hypotenuse 给定直角三角形的两个直角边的长度时，它返回斜边的长度。

   def hypotenuse(x,y):
       return math.sqrt(x**2+y**2)
   

3. 写一个函数is_between当x<=y<=z返回True 其他返回False

   def is_between(x,y,z):
       if x<=y<=z:
           return True
       else:
           return False
   

4. 写个回文函数,noon或者asdf 可以通过该函数判断是否回文。

   def check_hui(w):
       def first(word):
       return word[0]
       def last(word):
       return word[-1]
       def middle(word):
       return word[1:-1]
       if len(w)<=1:
           return True
       if first(w) != last(w):
           return False
       return check_hui(middle(w))
   

5. 我们说一个数a是b的乘方，如果a可以被b整除 并且a/b也是b的城防。编写一个函数is_power接受形参a和b 当a是b的乘方时返回True.

   def is_power(a,b):
       if a%b==0 and (a/b)%b==0:
           return True
       else:
           return False
   

6. 求a和b的最大公约数（GCD）

   def gcd(a, b):
     if a < b:
       a, b = b, a
     while b != 0:
       temp = a % b
       a = b
       b = temp
     return a
   

术语表(新手建议阅读并尝试理解):

• 临时变量(temporary variable):在复杂计算中用于保存中间值的变量
• 无效代码(dead code):程序中的一些代码，永远可能执行不到。常常是写在return语句之后的代码。
• None:函数返回的一种特殊值，当没有返回语句时，或者返回语句不带参数时，返回这个值
• 增量开发(incremental development):一个程序开发计划，每次通过只增加少量代码并加以测试的步骤，来减少调试
• 脚手架代码(scaffolding):在开发过程中使用的，但在最终版本中不需要的代码
• 守卫(guardian):一个编程模式，使用条件语句来检查并处理可能产生的错误