python实验_python实验之函数

步骤1常用内置函数

比如int函数可以把其他类型的数据转化为整数：>>> int('123')>>> int(12.34)>>> float('12.34')>>> str(1.23)>>> str(100)>>> bool(1)>>> bool('')

步骤2函数名函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

>>> a = abs

#变量a指向abs函数

>>> a(-1) #所以也可以通过a调用abs函数

步骤3定义函数在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。我们以自定义一个求绝对值的my_abs函数为例：def my_abs(x):

if x>=0:

return x

else:

return -x如果想定义一个什么事也不做的空函数，可以用pass语句,可以用来作为占位符。修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：

def my_abs(x):

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x >= 0:

return x

else:

return -x步骤4关键字参数可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。def person(name, age,**kw):

print('name:', name, 'age:', age,'other:', kw)

def writePerson(file,name,age, **kw):

f = open(file,"w")

result1 ="name:%s,age:%d,other:%s"%(name,age,str(kw))

f.write(result1)

f.close()函数person除了必选参数name和age外，还接受关键字参数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'}

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：>>> extra = {'city': 'Beijing', 'job': 'Engineer'}

>>> person('Jack', 24, city=extra['city'], job=extra['job'])

name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}当然，上面复杂的调用可以用简化的写法：>>> extra = {'city': 'Beijing', 'job': 'Engineer'}

>>>writePerson("/home/hcna-ai/exam4/result1.txt",'Jack', 24,**extra)**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。步骤5命名关键字参数如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：def person(name, age, *, city, job):

print(name, age,city, job)和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。调用方式如下：>>> person('Jack', 24, city='Beijing', job='Engineer')

Jack 24 Beijing Engineer如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：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 writePerson(file,name, age, *, city='Beijing', job):

f =open(file,"w")

result2 ="name:%s,age:%d,city:%s,job:%s"%(name,age,city,job)

f.write(result2)

f.close()由于命名关键字参数city具有默认值，调用时，可不传入city参数：>>> writePerson("/home/hcna-ai/exam4/result2.txt",'Jack',24, job='Engineer')使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数。步骤6参数组合在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。比如定义一个函数，包含上述若干种参数：

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)

def f2_write(file,a, b, c=0, *, d,**kw):

f= open(file,"w")

result3= "a=%s,b=%s,c=%s,d=%s,kw=%s"%(a,b,c,d,str(kw))

f.write(result3)

f.close()

在函数调用的时候，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': '#'}

>>>f2_write("/home/hcna-ai/exam4/result3.txt",*args,**kw)所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。步骤7递归函数使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。栈溢出解决方法：尾递归优化:解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：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)可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。

>>> f4 =open("/home/hcna-ai/exam4/result4.txt","w")

>>>f4.write(str(fact(10)))

>>>f4.close()