python之函数

函数定义

def functionname( parameters):   #没有参数可以不写()
    "函数_文档字符串"       #存放函数说明
    function_suite
    return [expression]   #没有返回值可以不加[]内容，也可以省略return

•  def是定义函数的关键字
• 文档字符串使用三个引号括起来
• 文档字符串下的为函数体

参数传递

函数参数的定义方式有4种，位置参数，关键参数，元组参数和字典参数。

位置参数

按照函数形式参数的顺序传递参数，一旦改变参数的顺序结果就会不同。

def func(x,y):
    print("x=%d y=%d"%(x,y))

func(3,4)
#输出：
x=3 y=4

func(4,3)
#输出：
x=4 y=3

 关键参数

关键参数指的是在传递参数时，不必考虑形式参数的具体先后顺序，以“形式参数=实际参数”的形式，直接告诉解释器，你想把实际参数传递给哪个实参。

def func(x,y):
    print("x=%d y=%d"%(x,y))

func(y=3,x=4)
#output:
x=4 y=3

 元组传递

元组参数主要用在实际业务逻辑中存在“可变参数”的情况，也就是说，你不能准确的说出实参的个数。这个时候就要使用“可变参数”的策略了。元组参数的本质其实就是将若干个实参封装成一个元组参数，这样就实现了一次传递参数个数可变的需求。例如：当函数的参数表示的是pisa的配料时，则配料的种类会因为pisa种类的不同而不同。这时就可以使用“元组参数”的策略了。

def func(*toppings):
    print(toppings)

func('mushrooms','extra','cheese')
func('mushrooms','extra')
#output:
('mushrooms', 'extra', 'cheese')
('mushrooms', 'extra')

 字典传递

这种策略是用来传递字典的，参数的形式是键值对的形式出现。

def func(**peoples):
    print(peoples)

func(name='aaron',age=25)
#output:
{'name': 'aaron', 'age': 25}

 从“func(name='aaron',age=25)”这段代码中可以看出，这种方式很容易跟“关键参数”的传参方式混淆。区分开的关键是这里的name表示的是字典里的键，而不是函数中的形参。如果出现了字典里的键和函数的形参一样的情况，那么解释器会将其理解为是“关键参数”，而不是字典传参，因此，在定义字典的键时要避免和其他形参一样。

def func(name,**people):
    print(name)
    print(people)

func(name='aaron',age='25',city='BeiJing')

#output:
aaron
{'age': '25', 'city': 'BeiJing'}

 参数传递方式优先级问题

解释器在解析函数参数时，会以位置参数，关键参数，元组参数，最后是字典参数的顺序来解析参数。这就解释了上述说所的“关键参数”和“字典传参”易混淆的问题。

def test(x,y=1,*a,**b):
    print(x,y,a,b)

test(1)
#output:
1 1 () {}

test(1,2)
#output:
1 2 () {}

test(1,2,3)
#output:
1 2 (3,) {}

test(1,2,3,4)
#output:
1 2 (3, 4) {}

test(x=1,y=2)
#output:
1 2 () {}

test(1,a=2)
#output:
1 1 () {'a': 2}

test(1,2,3,a=4)
#output:
1 2 (3,) {'a': 4}

test(1,2,3,y=4)
#output:
Traceback (most recent call last):
File "<pyshell#52>", line 1, in -toplevel-

test(1,2,3,y=4)
#output:
TypeError: test() got multiple values for keyword argument

 传递列表问题

有三种方式，分别是位置参数，关键参数和元组传参。不过在元组传参中，需要利用list方法将元组转化为列表。

位置参数

def func(names):
    print(names)
    names[1] = 'jujinyi'

names = ['aaron','jim']
func(names)
print(names) 
#output:
['aaron', 'jim']
['aaron', 'jujinyi']

 以上述的方式传递列表是，传递的是列表的原件，所以会永久性改变列表的值。如果说只想传递列表的附件，那么可以使用切片的方法实现。

def func(names):
    print(names)
    names[1] = 'jujinyi'

names = ['aaron','jim']
func(names[:])
print(names) 
#output:
['aaron', 'jim']
['aaron', 'jim']

 关键参数

本质上和位置参数其实是一样的，只不过是显示的传参而已。当然，对于实参的影响也是一样的，会永久性影响实参的值。

def func(num,names):
      print("num=%d"%num)
      print(names)
      names[1] = 'jujinyi'

names = ['aaron','jim']
func(names=names,num=25)
print(names)

#output：
num=25
['aaron', 'jim']
['aaron', 'jujinyi']

 元组传参

def func(*toppings):
    toppings = list(toppings)
    print(toppings)

func('mushrooms','extra','cheese')
func('mushrooms','extra')

#output：
['mushrooms', 'extra', 'cheese']
['mushrooms', 'extra']

 

传递字典的问题

字典的传递同样也有三种方法，分别是位置参数，关键参数和字典传参。

位置参数

def func(names):
     print(names)
     names['name'] = 'jujinyi'

people = {'name':'aaron','age':'25'}
func(people)
print(people)

#output:
{'name': 'aaron', 'age': 25}
{'name': 'jujinyi', 'age': 25}

 关键参数

def func(num,names):
     print("num=%d"%num)
     print(names)
     names['name'] = 'jujinyi'

people = {'name':'aaron','age':'25'}
func(names=people,num=25)
print(people)

#output:
num=25
{'name': 'aaron', 'age': 25}
num=25
{'name': 'jujinyi', 'age': 25}

 字典传参

def func(**people):
     print(people)

func(name='aaron',age='25')

#output:
{'name': 'aaron', 'age': 25}

 返回值

要想获取函数的执行结果，就可以用return语句把结果返回，注意:

• 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
• 如果未在函数中指定return,那这个函数的返回值为None