文档章节

python入门(八) -- 函数

兴趣使然的程序员
 兴趣使然的程序员
发布于 2017/05/10 16:14
字数 2920
阅读 10
收藏 1

函数类似于Java中的方法,是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

1、函数定义

函数定义的规则:

def 函数名(参数列表):
    [文档字符串,可选]
    函数体

可以用return [表达式]结束函数,也可以不用,依情况而定。如果不使用return返回值,实际上函数也会返回一个值None

例子:

# 生成指定边界的斐波那契数列
def fibonacci(n):
    # 文档字符串类似于Java中的文档注释,可以借助一些工具生成API文档
    """文档字符串:Print a Fibonacci series up to n."""
    a, b = 0, 1
    result = []
    while a < n:
        result.append(a)
        a, b = b, a+b
    if len(result) != 0:
        return result
    else:
        pass

# 在函数定义结束之后,最好空一行
print(fibonacci(2000))
# 当没有调用pass语句时,函数返回None
print(fibonacci(0))

2、全局变量、局部变量和参数调用

python中的函数和其他语言的函数/方法一样:

  • 函数内局部变量在每次函数调用时生成,函数结束时销毁
  • 由于python中没有Java中类似的“无引用的基本类型”,所以一直传递进函数的都是“引用”:形参在初始时,指向和传入的实参相同的地址。“更改形参指向的地址”并不会影响到实参,但是“更改形参指向的地址的内容”则会影响实参。
def method(num,str,tuple,list):
    # "="实际上意味着更改了类型的指向
    num += 1
    str = 'new str'
    tuple = ('a', 'b')
    list[0] = 1

n = 0
s = 'str'
t = ('a', 'b', 'c', ['this', 'is', 'a', 'list'])
l = [123, 345, 567]
method(n, s, t, l)
# 只有l被改变
print(n)
print(s)
print(t)
print(l)

和Java中不同:

  • python中的函数无法对全局参数进行赋值(这是由于和Java中不同,python的赋值语句和变量申明语句并没有任何差别,不像Java声明变量时需要指定类型),对外部的参数进行赋值必须通过global或者nonlocal实现
# 全局变量
n = 0


def method():
    # python解释器会认为是在方法中重新声明了一个“同名的局部变量”
    n = 1
  • 同样由于赋值语句和变量声明语句没有任何差别,python中有一种“类型可以改变”的假象:
# 看起来是类型改变了,实际上丢弃了原有的对象,新声明了一个对象
num = 123
num = '123'

# 如果Number和String进行运算,则会报错
num = 123+'123'

2.1、全局变量、局部变量详解

需要注意的有:

  • 方法内部只能访问全局变量,无法修改全局变量。同样,嵌套的方法也只能访问其外层方法的变量,而无法修改。
  • “无法修改”仅限于无法修改值,实际上对于“引用”,仍然可以修改。例如:

如上面所说,修改无效:

In [16]: num = 1

In [17]: def fun1():
    ...:     num = 2
    ...:     print(num)
    ...:     

In [18]: fun1()
2

In [19]: num
Out[19]: 1

但是对引用对象,不改变引用的情况下,可以改变值:

In [20]: list = [1,2,3,4,5]

In [21]: def fun1():
    ...:     list[0] = 'a new number'
    ...:     print(list)
    ...:     

In [22]: fun1()
['a new number', 2, 3, 4, 5]

In [23]: list
Out[23]: ['a new number', 2, 3, 4, 5]
  • 如果在方法内对全局变量(或上级局部变量)进行修改,或造成“shadowing”,导致无法对全局比变量进行访问,同时抛出错误“UnboundLocalError”。即如果下文中要对某个全局变量进行修改,就不能在这之前访问他。比如:
In [1]: num = 1

In [2]: def fun1():
   ...:     print(num)
   ...:     

In [3]: fun1()
1

In [4]: def fun1():
   ...:     print(num)
   ...:     num = 2
   ...:     

In [5]: fun1()
---------------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)
<ipython-input-5-ed0619e33a22> in <module>()
----> 1 fun1()

<ipython-input-4-c7d39297e45b> in fun1()
      1 def fun1():
----> 2     print(num)
      3     num = 2
      4 

UnboundLocalError: local variable 'num' referenced before assignment
  • 局部变量不能在函数外部被访问、修改。这个原则同样适用于函数内部的“函数”,因为和C语言类似,python中的函数其实也是一种特殊的对象(这点和Java不同)。例如:
In [26]: def fun1():
    ...:     def fun2():
    ...:         print("定义在fun1()内部的fun2()只能在fun1()内部调用")
    ...:     fun2()
    ...:     

In [27]: fun1()
定义在fun1()内部的fun2()只能在fun1()内部调用

In [28]: fun2()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-28-32d138681f85> in <module>()
----> 1 fun2()

NameError: name 'fun2' is not defined
  • 想要访问内部的函数,可以通过“闭包”来实现,见下方闭包的说明。
  • 可以使用Global和nonlocal强行在内部作用域中对外部变量进行修改,具体见:https://my.oschina.net/pierrecai/blog/906419

3、深入函数定义

注意,其它高级语言常见的函数重载,Python 是没有的,这是因为 Python 有默认参数这个功能,函数重载 的功能大都可以使用默认参数达到。

3.1、函数默认参数

  • 在定义参数时,可以给参数设定默认值
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    """可以设定默认参数"""
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no'):
            return False
        retries -= 1
        if retries < 0:
            raise OSError('uncooperative user')
        print(complaint)

# 函数调用时,没有默认值的参数必须给出,但是有默认值的参数可以不给出
ask_ok('Do you really want to quit?')

ask_ok('Do you really want to quit?',2)

ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

需要注意的是:

  • 函数的默认参数只被赋值一次,这在参数是“不可变类”和普通类的情况下会导致不同的结果:
i = 5


def method(num=i):
    print(num)

i = 6
# 由于Number为不可变类,每次print出的num一样
method()
method()
def method(list1=[]):
    list1.append('a')
    print(list1)

# 由于默认参数只赋值一次,每次方法调用都操作的是同一个List,效果会叠加
method()
method()
method()
# 最后一个输出['a', 'a', 'a', 'a']
method()
  • 如果不想让普通类默认值在后续调用中累积,可以使用下面的方法:
def method(list1=None):
    if list1 is None:
        list1 = []
    list1.append('a')
    print(list1)

3.2、关键字参数

python中在调用函数时,可以用“keyword = value”的形式进行:

def method(var1, var2='var2', var3='var3', var4=['var', '4']):
    print(var1)
    print(var2)
    print(var3)
    print(var4)

method(111)
method(var1='asd')
method(var1=123, var2='zxc')
method(111, '123', 123, '123')
method(111, var2='123')
method(var1='asd',var2=123)

需要注意的是:

  • 没有默认值的参数必须提供,有默认值的参数可以不提供
  • 如果不使用keyword,参数会按顺序读取
  • 如果使用keyword,keyword必须和形参名相匹配,此时可以不按顺序
  • 如果混合使用,非keyword参数必须在keyword之前
  • 任何参数都不可重复赋值

3.2.1、强制关键字参数

我们也能将函数的参数标记为只允许使用关键字参数。用户调用函数时将只能对每一个参数使用相应的关键字参数。

设定方法是将方法的第一个参数设置为*,后续全部使用关键字,比如:

def method(*,name="User",password="asdf"):
    print(name,password)

# 这样可以正常调用
method(name='alibaba')
# 这样则会报错
method('alibaba','asadf')

3.3、可变参数列表

在python中也像Java一样可以设置可变的参数列表。

  • 在Java中使用"参数类型... 参数名"表示可变的参数列表,并以“数组”的形式接受传入的数量不定的参数:
/**
 * @param strings   以数组的形式接受可变数量的参数
 */
public void method(String... strings){
    for (int i = 0; i < strings.length; i++) {
        System.out.println(strings);
    }
}
  • 在python中,同样可以用“数组”(python中称为元组)来接收数量不定的参数,形式为“*args”
  • 在python中,还可以使用“字典”(dictionary)来接收,形式为“**args”,但是不可以用在"*args"之前
def method(arg, *args, **keywords):
    print(arg)
    for arg in args:
        print(arg)
    for keyword in keywords:
        print(keyword, ":", keywords[keyword])

method("arg",
       "arg1", "arg2", "arg3",
       keyword1='arg4', keyword2='arg5')

注意:

  • 如果要定义可变列表,**args不能用在*args之前,普通参数不能在*args或者**args之后。
  • 可以在*args或者**args之后使用关键字参数

3.4、参数列表的分拆

和3.3中的相反,如果要传递的参数已经是元组或者字典,但是调用的函数却要求把这些拆开来传入,这是同样可以用“*”和“**”把元组和字典拆开:

# 正常调用
l = list(range(3, 6))
print(l)
# 拆分元组
list1 = list(range(*[3, 6]))
print(list1)


def method(var1, var2, var3, var4):
    print(var1)
    print(var2)
    print(var3)
    print(var4)

# 正常调用
method(1, 2, 3, 4)

# 拆分字典
method(**{"var1":1,"var2":2,"var3":3,"var4":4})

3.5、闭包

所谓“闭包”,指的是一个拥有许多变量和绑定了这些变量的环境的表达式(通常是一个函数),因而这些变量也是该表达式的一部分。

一般展示为下面的形式:

  • 函数b嵌套在函数a内部
  • 函数a返回函数b
  • 函数b可以对函数a的参数进行修改
In [30]: def fun1(x):
    ...:     def fun2(y):
    ...:         return x*y
    ...:     return fun2
    ...: 

In [31]: fun = fun1(5)

In [32]: fun
Out[32]: <function __main__.fun1.<locals>.fun2>

In [33]: fun(4)
Out[33]: 20

In [34]: fun1(5)(4)
Out[34]: 20

In [35]: fun2(4)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-35-95b8bef3aee7> in <module>()
----> 1 fun2(4)

NameError: name 'fun2' is not defined
  • 这样实现了前两点,但是如果要实现内部函数对外部函数的参数进行修改的话,还是需要引入nonlocal,如:

In [40]: def fun1(x):
    ...:     def fun2(y):
    ...:         x += 5
    ...:         print("+=实际上相当于先访问,后赋值")
    ...:         return x*y
    ...:     return fun2
    ...: 

In [41]: fun1(5)(4)
---------------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)
<ipython-input-41-a8dcf2873369> in <module>()
----> 1 fun1(5)(4)

<ipython-input-40-23b40a634958> in fun2(y)
      1 def fun1(x):
      2     def fun2(y):
----> 3         x += 5
      4         print("+=实际上相当于先访问,后赋值")
      5         return x*y

UnboundLocalError: local variable 'x' referenced before assignment

In [42]: def fun1(x):
    ...:     def fun2(y):
    ...:         nonlocal x
    ...:         x += 5
    ...:         print("+=实际上相当于先访问,后赋值")
    ...:         return x*y
    ...:     return fun2
    ...: 

In [43]: fun1(5)(4)
+=实际上相当于先访问,后赋值
Out[43]: 40

3.6、Lambda形式

和Java8中新增的Lambda特性相同,lambda表达式实际上是一个函数指针,常用于:

  • 替代只需要调用一两次的函数
  • 代表短小的匿名函数

Java中Lambda表达式的语法:

变量列表 -> 函数体

对应的python中的Lambda表达式的语法:

lambda 变量列表: 函数体

例如:

def add(n):
    return lambda x: x+n

f1 = add(42)


def f2(x):
    return x+42

# f1和f2相同
print(f1(0))
print(f2(0))
In [12]: fun = lambda x,y: x+y

In [13]: fun(1,2)
Out[13]: 3

lambda表达式还可以作为参数传递:

pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
# 意为根据元组对的第一个元素排序,即1234
pairs.sort(key=lambda pair: pair[0])
print(pairs)
pairs.sort(key=lambda pair: pair[1])

注意:

  • Java中Lambda表达式的参数列表需要用括号括起来,而python中不用

3.7、函数注解

函数注解以字典的形式存储在函数的__annotations__属性中,对函数的其他部分没有任何影响。

函数注解有三种:

  • 参数注解:定义在参数的":"后面
  • 返回注解:定义在参数列表的"->"后面
def method(var1: "参数1注解", var2: int='参数2初始值',var3:'参数3注解'='参数3初始值') -> "方法注解":
    print(method.__annotations__)
    print(var1)
    print(var2)
    print(var3)

method(1)

注意:

  • 如果参数有初始值,注解形式为(:后面跟注解,=后面跟初始值)
参数名:注解=初始值
  • 注解不只可以用字符串,还可以用int等,表示类型注解

和注解不同的是,函数字符串保存在__doc__属性中:

def method1():
    """这是一个文档字符串"""
    pass

# 直接通过调用__doc__属性
print(method1.__doc__)
# 通过help方法
help(method1)

 

© 著作权归作者所有

兴趣使然的程序员
粉丝 23
博文 112
码字总数 87412
作品 0
深圳
程序员
私信 提问
【Python Web学习路线】干货整理,不谈虚的,让你短时间高效学好它!

无论是大数据、人工智能还是机器学习,Python都是最热门的首选语言。 学好Python,可以从事Python Web工程师、Python数据分析、人工智能专家等岗位。本期专题,分享的主题是“如何成为一枚优...

Eddie_yang
2018/12/24
0
0
编程语言太难学?只因你还没试过Python!

Python语言可能是第一种即简单又功能强大的编程语言。它不仅适合于初学者,也适合于专业人员使用,更加重要的是,用Python编程是一种愉快的事。本身将帮助你学习这个奇妙的语言,并且向你展示...

极客学院
2015/05/18
2.1K
7
Python入门(八) 函数基础

定义一个函数: 1)必须以def开头 2)参数之间用,隔开 3)函数的内容以冒号:开始,并且缩进 4)不带表达式的return,相当于返回None def function_name(parameters): #do something ... ret...

kaedehao
2015/08/15
0
0
[Python图像处理] 十七.图像锐化与边缘检测之Roberts算子、Prewitt算子、Sobel算子和Laplacian算子

版权声明:本文为博主原创文章,转载请注明CSDN博客源地址!共同学习,一起进步~ https://blog.csdn.net/Eastmount/article/details/89001702 该系列文章是讲解Python OpenCV图像处理知识,前...

Eastmount
04/03
0
0
[Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正

版权声明:本文为博主原创文章,转载请注明CSDN博客源地址!共同学习,一起进步~ https://blog.csdn.net/Eastmount/article/details/88679772 该系列文章是讲解Python OpenCV图像处理知识,前...

Eastmount
03/20
0
0

没有更多内容

加载失败,请刷新页面

加载更多

spring 本类中方法调用另外一个方法事务不生效

1、在spring配置文件中添加 <aop:aspectj-autoproxy expose-proxy="true"/> 声明自动代理 2、AopContext.currentProxy()来获取代理类 3、使用代理类proxy进行代理调用内部声明了事务的方法 ......

重城重楼
18分钟前
4
0
项目 banner 乱弹

------------------------------------------ 村上春树 ------------------------------------- 如果我爱你,而你也正巧爱我,你头发乱了的时候,我会笑笑地替你拨一拨,然后手还留恋地在你...

宿小帅
30分钟前
3
0
PHP获取未来七天的日期和星期

php获取未来七天的日期和星期代码 第一步:获取需要天数的日期,然后调用函数 //获取未来七天的日期 for($i=1;$i<8;$i++){ $dateArray[$i]=date('Y-m-d',strtotime(d...

一只懒猫-
42分钟前
1
0
总结:IO模型

分类 多路复用 参考文章: https://www.jianshu.com/p/6a6845464770 https://www.cnblogs.com/zingp/p/6863170.html https://blog.csdn.net/sehanlingfeng/article/details/78920423......

浮躁的码农
45分钟前
1
0
fabric-sdk-java 1.4安装说明

Hyperledger Fabric Java SDK是开发基于Hyperledger Fabric区块链的Java应用之必备开发包。本文将介绍如何在Maven、Gradle和Eclipse中安装使用最新1.4版本的Hyperledger Fabric Java SDK。 ...

汇智网教程
46分钟前
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部