Python学习tips（2）

============================================================================

====   注该文档源于个人在学习廖雪峰老师的Python教程时候的随笔，参考网址：

====   https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/

====    其中有少量引用原句，并未标明，若侵权，将致歉删除。

====    本文属于学习笔记，如果理解不正确之处，还望海涵，多请指教

============================================================================= 

 

接Python学习tips（1）

8.       函数

 

8.1 函数调用

函数名本质上是对函数的对象的引用，完全可看做是一个变量，可以赋值给另外一个变量，也既是给函数起一个别名。

 

8.2 定义函数

定义函数要使用def语句，依次写出函数名，括号，括号中的参数和冒号（：），然后函数体要使用缩进。函数返回值使用return语句。

如果将函数my_func()函数定义保存为funcs.py文件中，那么可以在该文件的当前目录下启动Python解释器，用

from funcs import my_func

导入my_func()函数。注意funcs是文件名，不包含.py扩展名。

 

8.3空函数

如：

define temp_fun():

    pass

使用pass语句作为占位符。注意：pass语句可以用于其他地方作为占位符，让程序先跑起来。

 

8.4 函数参数检查

使用Python内置方法：isinstance(),如：

def my_abs(x):

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

        ralse TypeError('bad operand type')

    if x > 0:

       return x

   else

      return -x

 

8.5  返回多个参数

如：

import math

def move(x,y,step,angle = 0):

   nx = x + step*math.cos(angle)

   ny = y + step*math.sin(angle)

   return nx,ny

注：import math 语句表示导入math包，则可以引用math中的cos() sin()等函数

 

其实，这是一种假象，返回的是tuple元组，但是为了方便使用，省略了括号。

 

8.6  参数

8.6.1 位置参数

python中普通参数称为位置参数

如：

def power(x):

   return x*x

对于上述函数中的参数x就是位置参数

 

8.6.2 默认参数

在定义函数的时候，给参数初始化一个默认值，这个参数就称为默认参数

如：

def power(x,n = 2)

    s= 1

   while n > 0:

       n = n-1

       s = s * x

   return s

对于上述函数中n为默认参数，在调用时候，如果仅有一个参数，则n就使用默认的参数进行运算

 

Python的函数也允许传入默认参数。

设置默认参数注意事项：

a.必选参数在前，默认参数在后

b.另外，变化频次高的变量放在前面，变化频次小的变量放在后面。

c.当有多个默认参数的时候，只改变后一个默认参数的时候，调用函数时候需要将参数名带上

如：

def eroll(name,gender,age = 6,city = 'SH')

    print(name)

    …

 

调用:

enroll('ww','M',city = 'SQ')

d.重点：默认参数必须指向不变对象，如str,tuple,但不推荐list。

注：如果非要使用list等可变对象作为默认参数，请切记，加入判断使用默认参数的时候，对默认参数复位。

 

 

8.6.3 可变参数

所谓可变参数，是指函数的参数可以是多个不同的值，即传入参数的个数是可变的

当使用普通参数实现这样的功能的时候，需要首先将多个参数装载成list或者tuple，具体实现表现为传入参数时候多个参数需要使用()或者[]包裹。

而可变参数的方法不需要将参数使用()或者[]包裹，直接传入多个参数，个数不定。实现方法和普通参数发的函数定义区别仅仅在与多加上一个星号(*).

普通方法：

define sumup(numbers):

   sum = 0

   for x in numbers:

     sum = sum + x

   return sum

调用方法：

>>>sumup([1,2,3,4])

可变参数法：

define sumup(*numbers):

   sum = 0

   for x in numbers:

     sum = sum + x

   return sum

调用方法：

>>>sumup(1,2,3,4)

在实现可变参数的函数后，对于已经存在的list或tuple参数可以采用如下方法调用：

>>>nums = [1,2,3,4]

>>>sumup(*nums)

即使用星号*把list或者tuple中的参数变成可变参数传入函数中。

 

 

8.6.4关键字参数

可变参数函数允许传入0或者任意个参数，这些可变参数在函数调用的时候被自动组装成一个tuple.而关键字参数同样允许参数0或者任意个含参数名的参数，这些参数在函数内部自动组装成一个dict.

如：

  def person(name, age, **kw):

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

函数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'}

关键字参数的作用：扩展函数功能。

如下，一种简化调用关键字参数的方法。

 

>>> extra = {'city': 'Beijing','job': 'Engineer'}

>>> person('Jack', 24, **extra)

name: Jack age: 24 other: {'city':'Beijing', 'job': 'Engineer'}

 

8.6.5命名关键字参数

如：

def person(name, age, **kw):

   if 'city' in kw:

       # 有city参数，使用if...in...语句来判断，命名关键字参数是否包含某项

       pass

   if 'job' in kw:

       # 有job参数

       pass

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

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

def person(name, age, *, city, job):

 print(name, age, city, job)

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

调用方法，仅限传入如上命名的两种关键字。

 

 

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

 

def person(name, age, *args, city, job):

   print(name, age, args, city, job)

命名参数必须赋值。

命名参数可以有缺省值。

命名参数在使用的时候，要将key值标明，否则，会被当做可变参数（当然是，如果函数定义中带有可变参数；如果定义中没有带有可变参数，应该会报错吧？）

 

8.6.6 参数组合：

在Python中共有必选参数（位置参数？），默认参数，可变参数，关键字参数和命名关键字参数，共5种参数类型，这5中参数类型又可以组合使用。但，请注意，使用的时候参数顺序必须按照上述顺序来排列。

 

所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

对上述表述解释：任何参数的组合都可以看做是可变参数和关键字参数的组合。可以将必须参数/默认参数装载成tuple，其余参数都是关键字参数，装载成dict，打包放在可变参数中。

 

*args是可变参数，args接收的是一个tuple；输出参数时候可以看到用圆括号()包裹

**kw是关键字参数，kw接收的是一个dict。输出参数看到用大括号{}包裹

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

 

 

8.7  递归函数

8.7.1定义：如果一个函数内部调用自身，则称为递归函数。

如，求取阶乘的函数：

def fact(n):

   if n = 1:

       return 1

   return n*fact(n-1)

递归函数较之于循环函数逻辑更为清晰。但是递归函数的有着一下特点需要注意：

* 防止栈溢出，因为递归函数每调用一次自身就需要将前一次调用压入栈中，直到最终可计算才逐层退栈。如果递归深度较深，需要注意防止栈溢出

 

8.7.2尾递归

解决调用栈溢出的方法是通过尾递归优化。

定义：函数返回调用函数本身并且不能包含表达式。

如，将上述阶乘函数改为尾递归：

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_iter函数返回函数本身，在函数调用前就会将下一步的参数进行计算，传入。

尾递归实际上将递归的多次调用+多层调用栈转化成仅有多次调用来解决，在每次调用之前，计算出下次调用的参数，只占用一个栈帧。

尾递归的方式，在上述实例中可以理解为从尾部开始逆向运算，每次调用首先计算值再递归调用下一次。而递归方法，返回的是一个表达式，将运算压入栈中，直到满足条件的时候再运算，且是正向运算。