写在前面：为了更好的学习python，博主记录下自己的学习路程。本学习笔记基于廖雪峰的Python教程，如有侵权，请告知删除。欢迎与博主一起学习Pythonヽ(￣▽￣)ﾉ
函数的定义与调用
函数的定义用 def 函数名(参数): 的格式来定义，若有返回值则用return语句返回。需要注意的是，一旦执行return语句，则函数执行完毕，并将结果返回。比如定义一个算平方的函数：
>>>def power(x):
>>> return x*x函数的调用只需要写出函数名( 输入参数)即可，如：
>>>power(5)
25还能定义一个空函数
def nop():
pass函数的参数
对于power(x)函数，x是一个位置参数，位置参数可以定义多个，我们可以定义多个参数使得该power
()函数可以计算x的n次方。
def power(x,n):
a=1
while n>0:
a=a*x
n=n-1
return a>>>power(2,3) #把2赋给x，把3赋给n，即计算2的3次方
8
>>>power(2,5) #把2赋给x，把5赋给n，即计算2的5次方
32默认参数
接上面的例子，此时我们在使用power函数时必须输入两个参数，否则会出错，这样如果我们只需要通过power函数来计算平方时就会显得很麻烦。为了方便使用，我们可以通过设置默认参数来解决这一问题。
def power(x,n=2): #把n默认设置为2
a=1
while n>0:
a=a*x
n=n-1
return a>>>power(5) #在不输入参数n的值时，默认n为2
25
>>>power(5,3) #也可以输入参数n
125需要注意的是，默认参数要放在必选参数后面。默认参数必须指向不可变对象
可变参数
可变参数即传入的参数个数是可变的，允许你传入0个或任意个参数，而这些参数在函数内部组成一个tuple。当需要传入x个参数但x不确定时，就需要用到可变参数。如我们需要计算a2+b2+c2+…
def calc(numbers):
sum=0
for n in numbers:
sum=sum + n * n
return sum
我们可以把一个list或tuple传入numbers，算出结果
>>> calc([1, 2, 3])
14我们也可以把函数的参数改为可变参数，在参数名前加*
def calc(*numbers):
sum=0
for n in numbers:
sum=sum + n * n
return sum这样就可以传入多个参数
>>> calc(1, 2)
5
>>>nums=(1,2)
>>>calc(*nums) #在已有list或tuple时可以这样传入参数
5*nums表示把nums这个tuple的所有元素作为可变参数传进去
关键字参数
关键字参数允许你传入0个或任意个含参数名的参数，而这些关键字参数在函数内部组成一个dict。关键字参数的创建是在定义函数时再参数名前加**，如（以下代码转自廖雪峰的官方网站）
def person(name, age, **kw): #关键字参数的定义形式
print('name:', name, 'age:', age, 'other:', kw)
>>> person('Michael', 30) #关键字参数是可选参数，这里只传入必选参数
name: Michael age: 30 other: {}
>>> person('Bob', 35, city='Beijing') #传入一个关键字参数
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer') #传入两个关键字参数
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra) #当已经有存在的dict时，可以**dict传入
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
命名关键字参数
但我们需要指定关键字参数的名字时，就可以使用命名关键字参数，方法具体如下（以下代码转自廖雪峰的官方网站）
def person(name, age, *, city, job):
print(name, age, city, job)在*后面的视为命名关键字参数。如果在已经有了可变参数，则不需要加*，在可变参数后的默认为命名关键字参数。如
def person(name, age, *args, city, job):
print(name, age, args, city, job)值得注意的是，命名关键字参数与普通参数一样，定义了多少个在便要传入多少个，否则会出错，当然也可以设定默认值
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)多种参数组合使用
在使用多种参数时，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。（以下代码转自廖雪峰的官方网站）
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)在函数调用时，Python解释器自动按照参数位置和参数名把对应的参数传进去。
>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}同样的，在已用tuple或dict的情况下可以这样调用
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}可见，**对于任意函数，都可以通过类似func(*args, **kw)的形式调用它**，无论它的参数是如何定义的。
递归函数
如果在函数内部调用函数本身，则叫做递归函数。递归的逻辑清晰，事实上所有的递归函数都可以用循环语句来实现。如构造一个计算阶乘的函数（以下代码转自廖雪峰的官方网站）
def fact(n):
if n==1:
return 1
return n * fact(n - 1)>>> fact(1)
1
>>> fact(5)
120在使用递归函数时要防止栈溢出。
在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。——廖雪峰
为了防止栈溢出，我们可以改一下这个函数，构建一个尾递归，如下
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)对比一下两个函数的计算流程
===> 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===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120可见做了优化之后栈不会增长了。
遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。——廖雪峰
汉诺塔算法实现
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。——维基百科
简单而言，这个益智玩具的玩法是有三个柱子，我们分别假设为a、b、c，初始在a柱子上有由大到小堆放的圆盘，要把a柱子上的圆盘权移动到c柱子上，并且规定大圆盘不能再小圆盘上面。汉诺塔的移动问题可以用递归函数简单实现。
def move(n, a, b, c):
if n == 1: #当只有一个盘子时，直接从a移到c
print(a, '-->', c)
else:
move(n-1, a, c, b) #把a柱子上的上面n-1个盘子(借助c)移到b
move(1, a, b, c) #把a柱子上的最底下一个盘子(借助b)移到c
move(n-1, b, a, c) #把之前移到b的n-1个盘子(借助a)移到c
>>>move(3, 'A', 'B', 'C') #当n=3时，结果如下
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C 补充笔记
1.常用的函数。abs( )取绝对值，max( )取最大值，int( )把其他数据类型转化为整数，hex( )把整数转化为十六进制。
2.在Python交互环境中定义函数时，注意Python会出现…的提示。函数定义结束后需要按两次回车重新回到>>>提示符下。
3.pass语句可以用来作为占位符，如果有一定要写但没想好怎么写的内容时，可以先写pass，确保其他语句正常运行。比如：
num=0
if num<100:
pass
上面的语句并不会出错。
感谢你的阅读，欢迎评论与吐槽，和博主一起学习Python吧(￣▽￣)~*