定义函数
定义一个函数要使用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)