python 06 函数

函数，对象，模块

help() 函数用于查看函数或模块用途的详细说明。

 

def a():　　　　定义a函数

　　函数内容

>>a()

 

def a(b):　　一个参数b

　　print(b+3)

>>a(2)　　　　　　5

 

def a(num1,num2):　　可多个参数

　　return (num1+num2)　　　　返回值

 

>>print(a(1,2))　　a(1,2)=3,print(3)

3

 

def a(name):

　　'hi'

　　print(name+'aq')

>>a.__doc__　　输出文件开头注释的内容

hi

>>a(name=lo)　　关键字参数

loaq

 

def a(name=lo):　　默认参数

　　print(name+'ap')

>>a()　　　　存在默认参数，可不赋值

loap

>>a(we)　　存在默认参数，也可赋值覆盖参数

weap

 

def a(*b):　　　　收集参数，可多个参数（列表方式）

　　print(len(b),b[1])

>>a(0,1,2,3)　　

4,1

 

 

def a(*b,c):　　　　　　或c=2

　　print(b[1]+c)

>>a(0,1,2,c=3)　　　　存在收集参数和另外一个参数时，需要用默认参数定义

4

 

有返回值的是函数，没有返回值的叫过程，python只有函数

def a():

　　print(3)

>>a　　无返回值

>>print(a)　　返回none

none

 

def a():

　　return [1,'ho',3.4]

>>a()　　　　可返回列表

[1,'ho',3.4]

 

 

def a():

　　return 1,'ho',3.4　　，为元组

>>a()

（1,'ho',3.4)　　　　返回元组

 

def a(b):

　　c=b+1:

　　print(c)　　#c=3

c=1

a(2)

print(c)　　#c=1　　

 

当局部变量中修改全局变量c时，自动创建一个与c名字相同的局部变量

所以最后一个print(c)　　 为全局变量时的值

最好不要在函数内使用全局变量

 

c=1

def a(b):

　　global c　　在局部改变全局变量

　　c=b+1:

　　print(c)　　#c=3

 

print(c)　　c=3

 

内嵌函数

def a1():

　　print('0')

　　def a2():

　　　　print('1')

 

>>a1()　　　　不可直接调用a2

0

1

 

闭包 编程方式

def a1(x):

　　def a2(y):

　　　　return x*y

　　return a2

 

a2返回值为x*y

a1返回值a2

 

a1(3)(5)　　#x=3,y=5

 

def a1():

　　x=3

　　def a2():　　#x时上层（外部）函数变量，不可在下层（内部）函数中引用（修改）

　　　　x*=x

　　　　return x

　　return a2

此函数报错

 

 

第一种改变方式

def a1():

　　x=[3]

　　def a2():　　

　　　　x[0]*=x[0]

　　　　return x[0]

　　return a2

 

第二种改变方式

def a1():

　　x=3

　　def a2():　

　　　　nonlocal x　　　　#定义x不是局部变量　

　　　　x*=x

　　　　return x

　　return a2

 

def ds(x):

　　return 2 * x+1

>>ds(3)

7

 

g = lambda x: 2*x+1　　　#　定义了一个匿名函数

>>g(3)

7

 

def a(x,y):

　　rerurn x + y

g = lambda x,y : x+y

 

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

filter(function, iterable)

function -- 判断函数。

iterable -- 可迭代对象。

 

 

def is_odd(n):

    return n % 2 == 1

 

tmplist = filter(is_odd, range(0,11))

newlist = list(tmplist)

print(newlist)

[1, 3, 5, 7, 9]

return 0　　不返回任何东西

 

 

>>list(filter(lambda x :  x%2,range(10)))

[1,3,5,7,9]

 

lambda x : x%2 （匿名）判断函数 ，range(10) 迭代对象

filter 过滤， list换成列表

 

 

map() 会根据提供的函数对指定序列做映射。

map(a,b)　　　　a（函数），b序列　　a在b上对应的映射

 

>>>def square(x) :            # 计算平方数

...     return x ** 2

... 

>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方

[1, 4, 9, 16, 25]

>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数

[1, 4, 9, 16, 25]

 

# 提供了两个列表，对相同位置的列表数据进行相加

>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

[3, 7, 11, 15, 19]

 

阶乘

a=9

for i in range(1,9):　　

　　a *= i　　　　　　　　1~9的阶乘

print("%d" % (a))　　　　

 

递归实现

调用函数自身，有一个正确的返回条件

def a(n):

　　if n == 1:

　　　　return 1

　　else:

　　　　return n*a(n-1)

 

b=a(int(input()))

print("%d" % (b))

 

n=3

 

a(3)=3*a(2)

a(2)=2*a(1)

a(1)=1　　　　　　向上算回去

 

斐波那契数列(接近黄金比）

　　　1,　当n=1

f(n)=　1,   当n=2

　　　f(n-1)+f(n-2), 当n>2

 

def f(n):

　　n1=1

　　n2=1

　　n3=1

　　while (n-2) > 0:

　　　　n3 = n2+n1

　　　　n1=n2

　　　　n2=n3

　　　　n -=1

　　return n3

 

r=f(5)

print("%d" % (r))

 

while 3 > 0　　n3=2　　n1=1　　n2=2　　n=2（进1）.

while 2 > 0　　n3=3　　n1=2　　n2=3　　n=1

while 1 > 0　 　n3=5　　n1=3　　n2=5　　n=0

 

n3=n1+n2　　n1,n2　　前进1　　（参数）n-1

 

 

用递归实现

def fad (n):

　　if n<1:

　　　　return -1

　　if n==1 or n==2:

　　　　return 1

　　else:

　　　　return f(n-1)+f(n-2)

 

r=f(5)

if r != -1:

　　print ( "%d" % (r))

 

f(5)=f(4)+f(3)

f(4)=f(3)+f(2)

f(3)=f(2)+f(1)

f(2)=f(1)=1

 

递归总结

f(n)=f(n-1)+f(n-2)　　f(1),f(2)

 

a(n)=n*a(n-1)　　　　a(1)

 

 

用递归求解汉诺塔

#将x上的n个盘子借助y移动到z

def hanoi(n,x,y,z):　　　　n盘子，x起始，y借助，z目标

　　if n == 1:

　　　　print(x,'-->',z)

　　else:

　　　　hanoi(n-1,x,z,y)　　#将x上的n-1个盘子借助z移动到y上

　　　　print(x,'-->',z)　　#将最底下的最后一个盘子从x移动到z上

　　　　hanoi(n-1,y,x,z)　　#将y上的n-1个盘子借助x移动到z上

n = int(input())　　　　#层数（盘子）

hanoi(n,x,y,z)

 

问题：将x上的n个盘子借助y移动到z

将x上的n-1个盘子借助z移动到y

将x上的最底下的第n个盘子从x移动到z

将y上的n-1个盘子借助x移动到z

 

问题拆分：将x上的n-1个盘子借助z移动到y

将x上的n-2个盘子借助y移动到z

将x上的最底下的第n-1个盘子移动到y

将z上的n-2个盘子借助x移动到y

 

 

hanoi(n-1,x,z,y)　　#将n-1个盘子从x移动到y上

分部拆分　　n=3

hanoi(2,x,z,y)

　　hanoi(1,x,y,z)

　　print(x-->y)

　　hanoi(1,z,x,y)

 

hanoi(1,x,y,z)

　　print(x-->z)

print(x-->y)

hanoi(1,z,x,y)

　　print(z-->y)

 

将n-1个盘子从x移动到y上

x->z

x->y

z->y