python 函数

函数的定义

函数最重要的目的是方便我们重复使用相同的一段程序。

将一些操作隶属于一个函数，以后你想实现相同的操作的时候，只用调用函数名就可以，而不需要重复敲所有的语句。

 

创建函数

def 函数名 （参数列表） 
函数体

例如: 

def sum1(a,b): 
c = a + b 
return c 
e=1 
f=2 
print (sum1(e,f))

首先def 是定义函数名 sum1是函数名 
括号中的a, b是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。 
c = a + b 函数体的内部运算 
return c # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。 
print (sum1(e,f)) 调用函数并进行打印

 

形参和实参

形参：虚拟变量，在定义函数和函数体的时候使用形参。目的是在函数调用时接收实参，实参个数、类型要与形参一一对应。 
实参：调用函数时传给函数的参数。可以是常量、变量、表达式、函数。

def print_twice(bruce): 
print bruce 
print bruce #python 函数返回值可以用return 
这个函数的作用是：在调用的时候会把实参的值，给形参bruce，并将其输出2次。

 

默认参数

定义函数时，设定默认参数。当调用函数时，缺省参数如果没有值传入，则使用默认参数设定的值。

def a(x = []):
    print(id(x))
    x.append(1)
    print(x)
    print(id(x))
b=[1,2,3]
a(b)
2157718614216
[1, 2, 3, 1]
2157718614216

不定长参数

def it(*args):
    print(args,type(args))
b={'a':'1','b':'[1,2,3]'}
it(b)
({'a': '1', 'b': '[1,2,3]'},) <class 'tuple'>

两个**动态参数

def it(**kargs):
    print(kargs,type(kargs))
b={'a':'1','b':'[1,2,3]'}
it(c=b,d=b)
{'c': {'a': '1', 'b': '[1,2,3]'}, 'd': {'a': '1', 'b': '[1,2,3]'}} <class 'dict'>

一个的动态参数会将输入转换成元组 
两个*的动态参数会将输入转换成字典，传参的时候要'k':'v'的方式传输。

注意区别

def show(*arg,**xukq):
    print(arg,type(arg))
    print(xukq,type(xukq))
l = [1,2,3]
d = {'a':'333','b':'iteemo'}
show(*l,d)
输出：
(1, 2, 3, {'a': '333', 'b': 'iteemo'}) <class 'tuple'>
{} <class 'dict'>

def show(*arg,**xukq):
    print(arg,type(arg))
    print(xukq,type(xukq))
l = [1,2,3]
d = {'a':'333','b':'iteemo'}
show(l,d)
输出：
(1, 2, 3, {'a': '333', 'b': 'iteemo'}) <class 'tuple'>
{} <class 'dict'>

def show(*arg,**xukq):
    print(arg,type(arg))
    print(xukq,type(xukq))
l = [1,2,3]
d = {'a':'333','b':'iteemo'}
show(*l,**d)
输出：
(1, 2, 3) <class 'tuple'>
{'a': '333', 'b': 'iteemo'} <class 'dict'>

return

return的作用：

（1）结束函数

（2）返回某个对象

注意点：

如果不加return，默认返回None。

如果return有个对象，那么会将多个对象封装成一个元组。

遇到return语句，就会停止执行并返回结果。

 

局部变量

你在函数定义中声明的变量，他们与在函数外使用的其它同名变量没有任何关系，即变量名称对函数来说是局部的。这叫变量的范围。所有变量都有它们被声明的块的范围，从名称定义的点开始。

x = 50
def func(x):
    print('x等于', x)
    x = 2
    print('局部变量x改变为', x)
func(x)
print('x一直是', x)
x等于 50
局部变量x改变为 2
x一直是 50

global 声明全局变量

x = 50
def func():
    global x
    print('x的值是', x)
    x = 2
    print('全局变量x改为', x)
func()
print('x的值是', x)
x的值是 50
全局变量x改为 2
x的值是 2

内置函数

 

lambda

lambda作为一个表达式，定义了一个匿名函数例子：

def funb(a):
    b = a + 1
    return b
c = funb(4)
print(c)
func = lambda a:a+1
ret =func(99)
print(ret)
5
100

map函数

它接收一个函数和一个 list，并通过把函数依次作用在 list 的每个元素上，得到一个新的 list 并返回。

>>> li = [1,2,3,4]
>>> new_li = map(lambda x:x*10,li)
>>> print(new_li)
[10, 20, 30, 40]

>>> li = [1,2,3,4]
>>> def funa(x):
...     return x*10
... 
>>> new_li2 = map(funa,li)
>>> print(new_li2)
[10, 20, 30, 40]

filter

和map()类似，filter()也接收一个函数和一个list。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

>>> li = [1,2,3,4]
>>> def funb(x):        
...     if x > 2:       
...             return True
...     else:
...             return False
... 
>>> new_li = filter(funb,li)
>>> print(new_li)          
[3, 4]