美文网首页
python学习笔记之--函数

python学习笔记之--函数

作者: itsenlin | 来源:发表于2022-01-08 21:16 被阅读0次

概念

函数:一组单独的代码逻辑块,可以有输入(称为参数),可以有输出(称为返回值)
过程:在python中等同于函数
方法:就是类中的函数

函数定义方法

def func_name(arglist):
    ''' func_doc'''
    func_suit

说明:

  • 与C语言不同,python语言的函数没有声明和定义的区分
  • 函数没有对返回值做定义,可以有以下三种情况
    1. 返回值个数为0个,即没有显示的return语句,则默认会返回None
      >>> def foo():
      ...     print("foo")
      ... 
      >>> ret = foo()
      foo
      >>> ret
      >>> type(ret)
      <class 'NoneType'>
      >>> 
      
    2. 返回值个数为1个,则表示返回的是一个对象obj
      ```python
      >>> def getList():
      ...     return [1, 2, 3]
      ... 
      >>> ret = getList()
      >>> ret
      [1, 2, 3]
      >>> type(ret)
      <class 'list'>
      >>> 
      ```
    
    1. 返回值个数大于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'>)
      >>> 
      ```
    
  • 函数参数定义时没有类型信息,根据调用时传入的值进行分析
    >>> 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
>>>

相关文章

网友评论

      本文标题:python学习笔记之--函数

      本文链接:https://www.haomeiwen.com/subject/rtlscrtx.html