重生,腾讯手机管家下载,性爱网-玩文字,中华文学博大精深,在线学习吧

admin 2019-05-16 阅读:161

函数是安排好的,可重复运用的,用来完结单一,或相关联功用的代码段。

函数能进步运用的模块性,和代码的重复利用率。你现已知道Python供给了许多内建函数,比方print()。但你也能够自己创立函数,这被叫做用户自界说函数。


界说一个函数

你能够界说一个由自己想要功用的函数,以下是简略的规矩:

  • 函数代码块以 def 关键词最初,后接函数标识符称号和圆括号 ()
  • 任何传入参数和自变量有必要放在圆括号中心,圆括号之间能够用于界说参数。
  • 函数的榜首行句子能够挑选性地运用文档字符串—用于寄存函数阐明。
  • 函数内容以冒号开始,而且缩进。
  • return [表达式] 完毕函数,挑选性地回来一个值给调用方。不带表达式的return相当于回来 None。

语法

Python 界说函数运用 def 关键字,一般格局如下:

def 函数名(参数列表):
函数体

默许情况下,参数值和参数称号是按函数声明中界说的次序匹配起来的。

实例

让咱们运用函数来输出"Hello World!":

>>>def hello() :
print("Hello World!")


>>> hello()
Hello World!
>>>

更复杂点的运用,函数中带上参数变量:

实例(Python 3.0+)

#!/usr/bin/python3

# 核算面积函数
def area(width, height):
return width * height

def print_welcome(name):
print("Welcome", name)

print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

以上实例输出成果:

Welcome Runoob
width = 4 height = 5 area = 20

函数调用

界说一个函数:给了函数一个称号,指定了函数里包括的参数,和代码块结构。

这个函数的根本结构完结今后,你能够经过另一个函数调用履行,也能够直接从 Python 命令提示符履行。

如下实例调用了 printme() 函数:

实例(Python 3.0+)

#!/usr/bin/python3

# 界说函数
def printme( str ):
# 打印任何传入的字符串
print (str)
return

# 调用函数
printme("我要调用用户自界说函数!")
printme("再次调用同一函数")

以上实例输出成果:

我要调用用户自界说函数!
再次调用同一函数

参数传递

在 python 中,类型归于目标,变量是没有类型的:

a=[1,2,3]
a="Runoob"

以上代码中,[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,她只是是一个目标的引证(一个指针),能够是指向 List 类型目标,也能够是指向 String 类型目标。

可更改(mutable)与不行更改(immutable)目标

在 python 中,strings, tuples, 和 numbers 是不行更改的目标,而 list,dict 等则是能够修正的目标。

  • 不行变类型:变量赋值 a=5 后再赋值 a=10,这儿实践是重生成一个 int 值目标 10,再让 a 指向它,而 5 被丢掉,不是改动a的值,相当于重生成了a。
  • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修正了。

python 函数的参数传递:

  • 不行变类型:相似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a目标本身。比方在 fun(a)内部修正 a 的值,只是修正另一个仿制的目标,不会影响 a 本身。
  • 可变类型:相似 c++ 的引证传递,如 列表,字典。如 fun(la),则是将 la 真实的传过去,修正后fun外部的la也会受影响

python 中一切都是目标,严厉含义咱们不能说值传递仍是引证传递,咱们应该说传不行变目标和传可变目标。

python 传不行变目标实例

实例(Python 3.0+)

#!/usr/bin/python3

def ChangeInt( a ):
a = 10

b = 2
ChangeInt(b)
print( b ) # 成果是 2

实例中有 int 目标 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的方法仿制了变量 b,a 和 b 都指向了同一个 Int 目标,在 a=10 时,则重生成一个 int 值目标 10,并让 a 指向它。

传可变目标实例

可变目标在函数里修正了参数,那么在调用这个函数的函数里,原始的参数也被改动了。例如:

实例(Python 3.0+)

#!/usr/bin/python3

# 可写函数阐明
def changeme( mylist ):
"修正传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return

# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

传入函数的和在结尾添加新内容的目标用的是同一个引证。故输出成果如下:

函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]

参数

以下是调用函数时可运用的正式参数类型:

  • 必需参数
  • 关键字参数
  • 默许参数
  • 不定长参数

必需参数

必需参数须以正确的次序传入函数。调用时的数量有必要和声明时的相同。

调用printme()函数,你有必要传入一个参数,否则会呈现语法过错:

实例(Python 3.0+)

#!/usr/bin/python3

#可写函数阐明
def printme( str ):
"打印任何传入的字符串"
print (str)
return
#调用printme函数
printme()

以上实例输出成果:

Traceback (most recent call last):
File "test.py", line 10, in
printme()
TypeError: printme() missing 1 required positional argument: 'str'

关键字参数

关键字参数和函数调用联系严密,函数调用运用关键字参数来确认传入的参数值。

运用关键字参数答应函数调用时参数的次序与声明时不一致,由于 Python 解说器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时运用参数名:

实例(Python 3.0+)

#!/usr/bin/python3

#可写函数阐明
def printme( str ):
"打印任何传入的字符串"
print (str)
return

#调用printme函数
printme( str = "Bighua教程")
以上实例输出成果:
Bighua教程

以下实例中演示了函数参数的运用不需求运用指定次序:

实例(Python 3.0+)

#!/usr/bin/python3

#可写函数阐明
def printinfo( name, age ):
"打印任何传入的字符串"
print ("姓名: ", name)
print ("年纪: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )

以上实例输出成果:

姓名: runoob
年纪: 50

默许参数

调用函数时,假如没有传递参数,则会运用默许参数。以下实例中假如没有传入 age 参数,则运用默许值:

实例(Python 3.0+)

#!/usr/bin/python3

#可写函数阐明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("姓名: ", name)
print ("年纪: ", age)
return

#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

以上实例输出成果:

姓名: runoob
年纪: 50
------------------------
姓名: runoob
年纪: 35

不定长参数

你或许需求一个函数能处理比最初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。根本语法如下:

def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]

加了星号 * 的参数会以元组(tuple)的方式导入,寄存一切未命名的变量参数。

实例(Python 3.0+)

#!/usr/bin/python3

# 可写函数阐明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)

# 调用printinfo 函数
printinfo( 70, 60, 50 )

以上实例输出成果:

输出: 
70
(60, 50)

假如在函数调用时没有指定参数,它便是一个空元组。咱们也能够不向函数传递未命名的变量。如下实例:实例(Python 3.0+)

#!/usr/bin/python3

# 可写函数阐明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return

# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

以上实例输出成果:

输出:
10
输出:
70
60
50

还有一种便是参数带两个星号 **根本语法如下:

def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]

加了两个星号 ** 的参数会以字典的方式导入。

实例(Python 3.0+)

#!/usr/bin/python3

# 可写函数阐明
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)

# 调用printinfo 函数
printinfo(1, a=2,b=3)

以上实例输出成果:

输出: 
1
{'a': 2, 'b': 3}

声明函数时,参数中星号 * 能够独自呈现,例如:

def f(a,b,*,c):
return a+b+c

假如独自呈现星号 * 后的参数有必要用关键字传入。

>>> def f(a,b,*,c):
... return a+b+c
...
>>> f(1,2,3) # 报错
Traceback (most recent call last):
File "", line 1, in
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

匿名函数

python 运用 lambda 来创立匿名函数。

所谓匿名,意即不再运用 def 句子这样规范的方式界说一个函数。

  • lambda 只是一个表达式,函数体比 def 简略许多。
  • lambda的主体是一个表达式,而不是一个代码块。只是能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数具有自己的命名空间,且不能拜访自己参数列表之外或大局命名空间里的参数。
  • 尽管lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的意图是调用小函数时不占用栈内存然后添加运转功率。

语法

lambda 函数的语法只包括一个句子,如下:

lambda [arg1 [,arg2,.....argn]]:expression

如下实例:

实例(Python 3.0+)

#!/usr/bin/python3

# 可写函数阐明
sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

以上实例输出成果:

相加后的值为 : 30
相加后的值为 : 40

return句子

return [表达式] 句子用于退出函数,挑选性地向调用方回来一个表达式。不带参数值的return句子回来None。之前的比如都没有演示怎么回来数值,以下实例演示了 return 句子的用法:

实例(Python 3.0+)

#!/usr/bin/python3

# 可写函数阐明
def sum( arg1, arg2 ):
# 回来2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

以上实例输出成果:

函数内 : 30
函数外 : 30

变量效果域

Python 中,程序的变量并不是在哪个方位都能够拜访的,拜访权限决议于这个变量是在哪里赋值的。

变量的效果域决议了在哪一部分程序能够拜访哪个特定的变量称号。Python的效果域一共有4种,分别是:

  • L (Local) 部分效果域
  • E (Enclosing) 闭包函数外的函数中
  • G (Global) 大局效果域
  • B (Built-in) 内置效果域(内置函数地点模块的规模)

以 L –> E –> G –>B 的规矩查找,即:在部分找不到,便会去部分外的部分找(例如闭包),再找不到就会去大局找,再者去内置中找。

g_count = 0 # 大局效果域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 部分效果域

内置效果域是经过一个名为 builtin 的规范模块来完结的,可是这个变量名本身并没有放入内置效果域内,所以有必要导入这个文件才能够运用它。在Python3.0中,能够运用以下的代码来检查究竟预界说了哪些变量:

>>> import builtins
>>> dir(builtins)

Python 中只要模块(module),类(class)以及函数(def、lambda)才会引进新的效果域,其它的代码块(如 if/elif/else/、try/except、for/while等)是不会引进新的效果域的,也便是说这些句子内界说的变量,外部也能够拜访,如下代码:

>>> if True:
... msg = 'I am from Runoob'
...
>>> msg
'I am from Runoob'
>>>

实例中 msg 变量界说在 if 句子块中,但外部仍是能够拜访的。

假如将 msg 界说在函数中,则它便是部分变量,外部不能拜访:

>>> def test():
... msg_inner = 'I am from Runoob'
...
>>> msg_inner
Traceback (most recent call last):
File "", line 1, in
NameError: name 'msg_inner' is not defined
>>>

从报错的信息上看,阐明晰 msg_inner 未界说,无法运用,由于它是部分变量,只要在函数内能够运用。


大局变量和部分变量

界说在函数内部的变量具有一个部分效果域,界说在函数外的具有大局效果域。

部分变量只能在其被声明的函数内部拜访,而大局变量能够在整个程序规模内拜访。调用函数时,一切在函数内声明的变量称号都将被加入到效果域中。如下实例:

实例(Python 3.0+)

#!/usr/bin/python3

total = 0 # 这是一个大局变量
# 可写函数阐明
def sum( arg1, arg2 ):
#回来2个参数的和."
total = arg1 + arg2 # total在这儿是部分变量.
print ("函数内是部分变量 : ", total)
return total

#调用sum函数
sum( 10, 20 )
print ("函数外是大局变量 : ", total)

以上实例输出成果:

函数内是部分变量 : 30
函数外是大局变量 : 0

global 和 nonlocal关键字

当内部效果域想修正外部效果域的变量时,就要用到global和nonlocal关键字了。

以下实例修正大局变量 num:

实例(Python 3.0+)

#!/usr/bin/python3

num = 1
def fun1():
global num # 需求运用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
print(num)

以上实例输出成果:

1
123
123

假如要修正嵌套效果域(enclosing 效果域,外层非大局效果域)中的变量则需求 nonlocal 关键字了,如下实例:

实例(Python 3.0+)

#!/usr/bin/python3

def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()

以上实例输出成果:

100
100

别的有一种特殊情况,假定下面这段代码被运转:

实例(Python 3.0+)

#!/usr/bin/python3

a = 10
def test():
a = a + 1
print(a)
test()

以上程序履行,报错信息如下:

Traceback (most recent call last):
File "test.py", line 7, in
test()
File "test.py", line 5, in test
a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment

过错信息为部分效果域引证过错,由于 test 函数中的 a 运用的是部分,未界说,无法修正。

修正 a 为大局变量,经过函数参数传递,能够正常履行输出成果为:

实例(Python 3.0+)

#!/usr/bin/python3

a = 10
def test(a):
a = a + 1
print(a)
test(a)

履行输出成果为:

11