python 函数，,函数的定义函数最重要

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 = 50def func(x):    print(‘x等于‘, x)    x = 2    print(‘局部变量x改变为‘, x)func(x)print(‘x一直是‘, x)x等于 50局部变量x改变为 2x一直是 50

global 声明全局变量

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

内置函数

lambda

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

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

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]

python 函数