(二)python函数

定义函数
定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，而后，在缩进块中编写函数体，函数的返回值用return语句返回。

##定义myabs函数
def my_abs(x):   ## 注意这个函数 不管x 是否大于或者小于零 他都会返回正整数 假设x=9  -x = - -9 = 9
    if x >= 0:
        return x
    else:
        return -x
##函数体内部的语句在执行时，一旦执行到return时函数就执行完毕，并将结果返回

from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）：

>>> from abstest import my_abs                  
>>> my_abs(-9)                                         
>>> 9                                                       
>>> _

空函数(若是想定义一个什么事也不作的空函数，能够用pass语句)：

def nop():
    pass

参数检查
调用函数时，若是参数个数不对，Python解释器会自动检查出来，并抛出TypeError
对参数类型作检查，只容许整数和浮点数类型的参数。数据类型检查能够用内置函数isinstance()实现：

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

练习：
请定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程 ax^2+bx+c=0 ax +bx+c=0 的两个解。

import math

def quadratic(a,b,c):

    t = (b * b - 4 * a * c)

    if t >0:

        x1 = (-b + math.sqrt(t)) / (2 * a)

        x2 = (-b - math.sqrt(t)) / (2 * a)

        print('x1 =',x1,'x2 =',x2)

        return '此方程有两个解'

    elif t == 0:

        x1 = (-b + math.sqrt(t)) / (2 * a)

        x2 = (-b + math.sqrt(t)) / (2 * a)

        print(x1,'=',x2)

        return '此方程两个解相等'

    else:

        return '此方程无解'

a = float(input('请输入a : '))

while a == 0:

    print('a不能为0')

    a = float(input('请从新输入a : '))

b = float(input('请输入b : '))

c = float(input('请输入c : '))

print(quadratic(a,b,c))

函数的参数
计算x2的函数：

def power(x):
    return x * x
#power(x)函数，参数x就是一个位置参数。
#当咱们调用power函数时，必须传入有且仅有的一个参数x
>>> power(5)
25

默认参数，当定义了默认参数后 能够少传一个位置参数

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1   
        s = s * x
    return s
##当咱们调用power(5)时，至关于调用power(5, 2) = 25

可变参数：变参数就是传入的参数个数是可变的，能够是1个、2个到任意个，还能够是0个。
请计算a2 + b2 + c2 + ……。

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
##数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，所以，函数代码彻底不变。可是，调用该函数时，能够传入任意个参数，包括0个参数。若是没有这个*号那么在传入参数的时候要先组成一个列表或者元组。

已经有一个list或者tuple，要调用一个可变参数怎么办？能够这样作：

##在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14

关键字参数:容许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict(zi'd)

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
>>> person('Michael', 30)
name: Michael age: 30 other: {}

命名关键字参数：限制关键字参数的名字，就能够用命名关键字参数，例如，只接收city和job做为关键字参数。这种方式定义的函数以下：

def person(name, age, *, city, job):
    print(name, age, city, job)
##命名关键字参数须要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

关键字参数必须指明传入 不是就会报错
调用方式以下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

递归函数：在函数内部，能够调用其余函数。若是一个函数在内部调用自身自己，这个函数就是递归函数。
好比阶乘n! = 1 x 2 x 3 x ... x n
fact(n)能够表示为n x fact(n-1)

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
    #####
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

汉诺塔的移动能够用递归函数很是简单地实现。

请编写move(n, a, b, c)函数，它接收参数n，表示3个柱子A、B、C中第1个柱子A的盘子数量，而后打印出把全部盘子从A借助B移动到C的方法

def hanio(n,a,b,c):
    if n ==1:   ## 当只有一个盘子的时候直接将A盘移动到C
        print(a,"-->",c)
    else:     ## 主要 当大于1 时 ，简化逻辑的思路 咱们把盘子分红2部分 n,n-1
        hanio(n-1,a,c,b)  ##首先咱们把N-1的部分经过C 移动到B 上 那么如今 A 还剩下一个底层最大的盘子 
        print(a,"-->",c)  ##把底层最大的盘子 从A 移动到C
        hanio(b,a,c)   ##剩下的 把刚才移动的B的盘子 经过空闲的A 移动到C  必定要当作一个总体

    测试 hanio(3,a,b,c)