概念
函数:一组单独的代码逻辑块,可以有输入(称为参数),可以有输出(称为返回值)
过程:在python中等同于函数
方法:就是类中的函数
函数定义方法
def func_name(arglist):
''' func_doc'''
func_suit
说明:
- 与C语言不同,python语言的函数没有声明和定义的区分
- 函数没有对返回值做定义,可以有以下三种情况
- 返回值个数为0个,即没有显示的return语句,则默认会返回None
>>> def foo(): ... print("foo") ... >>> ret = foo() foo >>> ret >>> type(ret) <class 'NoneType'> >>>
- 返回值个数为1个,则表示返回的是一个对象obj
```python >>> def getList(): ... return [1, 2, 3] ... >>> ret = getList() >>> ret [1, 2, 3] >>> type(ret) <class 'list'> >>> ```
- 返回值个数大于1个,则返回的是一个tuple对象
```python >>> def getTuple(): ... return (1, 2, 3) ... >>> def getTuple1(): ... return 1, 2, 3 ... >>> ret = getTuple() >>> ret1 = getTuple1() >>> ret, ret1 ((1, 2, 3), (1, 2, 3)) >>> type(ret), type(ret1) (<class 'tuple'>, <class 'tuple'>) >>> ```
- 返回值个数为0个,即没有显示的return语句,则默认会返回None
- 函数参数定义时没有类型信息,根据调用时传入的值进行分析
>>> def max(a, b): ... if a < b: ... return -1 ... elif a == b: ... return 0 ... else: ... return 1 ... >>> ret = max(1, 2) >>> ret -1 >>> ret = max('abc', 'a') >>> ret 1 >>>
- 类似go语言,python函数很像一等公民,可以直接赋值给另外一个变量
>>> def foo(): ... print("foo") ... >>> bar = foo >>> bar() foo >>>
函数参数
参数传递
类似C/C++语言,python语言函数参数传递分为两种
- 不可变参数传递,类似于值传递,即函数体内对参数的修改不会影响实参本身,这类包含python的不可变对象:整数、字符串、元组等
>>> num = 10 >>> def foo(a): ... a += 1 ... print(a) ... >>> num 10 >>> foo(num) 11 >>> num 10 >>>
- 可变参数传递,类似于引用或者指针,与前者正好相反,这类包含python的可变对象:列表、字典等
>>> list = [1, 2, 3] >>> def foo(a): ... a.append([3, 4, 5]) ... print(a) ... >>> list [1, 2, 3] >>> foo(list) [1, 2, 3, [3, 4, 5]] >>> list [1, 2, 3, [3, 4, 5]] >>>
默认参数
与其他高级语言类似,python也有默认参数特性,即在定义函数时,可以对右边参数赋值,如果调用时不传入对应位置的参数,则使用默认值
>>> def foo(a, b, c = 10):
... print(a, b, c)
...
>>> foo(1, 2)
1 2 10
>>> foo(1, 2, 3)
1 2 3
>>>
关键字参数
python语言此特性很有意思,可以在调用函数时,指定形参
的名字进行赋值,这样参数的顺序可以不按形参的顺序来,如下
>>> def foo(a, b):
... print("a = " + str(a) + ", b = " + str(b))
...
>>> foo(b=1, a=2)
a = 2, b = 1
>>>
不定长参数
类似print函数,可以接收n个参数,n>=0
python语言通过元组和字典两种方式来实现
- 通过元组实现不定长参数,使用单
*
号def func(positionArgs, *tuple): func_suit >>> def foo(a, *bs): ... for t in bs: ... print(t) ... print(a) ... >>> foo(1) 1 >>> foo(1, 2, 3) 2 3 1 >>>
- 通过字典实现不定长参数,使用双
*
号def func(positionArgs, **dict): func_suit >>> def foo(a, **bs): ... for key in bs.keys(): ... print("%s : %s" % (key, bs[key])) ... print(a) ... >>> foo(1, b=2, c=3) b : 2 c : 3 1 >>>
lambda
python语言允许用lambda关键字创建匿名函数,定义如下
lambda [arg1, [arg2, ... argN]]: expression
只有参数和函数体,没有函数名,所以也叫匿名函数
根据前面介绍,这种lambda函数可以赋值给一个变量,通过变量来调用,如下
>>> true = lambda :True
>>> type(true)
<class 'function'>
>>> true()
True
>>> add = lambda x, y: x+y
>>> add(1, 2)
3
>>>
闭包
在python语言中,函数可以嵌套定义,也即可以在一个函数中再定义另外一个函数(称为内部函数),如下
>>> def foo():
... def bar():
... print("foo.bar")
... bar()
...
>>> foo()
foo.bar
>>>
闭包:如果在一个内部函数里,对在外部作用域(非全局,如在外部函数中定义的)变量进行引用,那么这个内部函数
就被称为闭包
,如下
>>> def counter(start=0):
... count = [start]
... def inner():
... count[0] += 1
... return count[0]
... return inner
...
>>> c = counter()
>>> c()
1
>>> c()
2
>>>
网友评论