python【4】-函数,python函数

python基础-函数,python基础函数

函数是一种可被频繁调用的一段作用块

一、定义  

def 函数名(参数):
    ....
    函数体
    ....
    返回值

  要求:

  • def  : 函数的重要字
  • 函数名:以往程序调用时行使函数名
  • 函数体:运维一些运算的代码段
  • 再次回到值:函数体运营成功与否,大概别的结果,供给回到给调用者,暗许重临None
  • 参数:

    普通参数

 私下认可参数

 动态参数

金沙国际官网 1

# ######定义函数#######

# name为函数的形式参数,简称形参
def func(name):
    print name

# ######执行函数#######


# “zzy”为函数func的实际参数,简称实参
func("zzy")

一般参数
金沙国际官网 1

def func(name,age=20):
    pring "%s:%s" %(name,age)

# 指定参数
func("Qiutujs",30)

#使用默认参数
func("Qiutujs")

注:默认参数必须放在参数列表的最后

私下认可参数
金沙国际官网 1

def func(*args):
    print(args)


# 执行方式一
func(11,22,33,44)


# 执行方式二
li=[11,22,33,44]
func(*li)   #如果不加*,函数func会把li作为一个元素打印出来

动态参数
金沙国际官网 1

def func(**kwargs):
    print(kwargs)


#执行方式一
func(name="zzy",age=33)


#执行方式二
li={"name":"zzy","age":33,"job":"IT"}
func(**li)

注:这个动态参数是把传入的参数转为字典类型,因此输入参数时一定要以键值对的形式输入

动态参数
金沙国际官网 1

def func(*args,**kwargs):
    print (args)
    pring (kwargs)

动态参数(万能参数)

函数是一种可被再三调用的一段功用块 一、定义 def 函数名(参数): ….
函数体 …. 重回值 要求: def : 函数的…

函数是公司好的,可重复使用的,用来贯彻单一,或相关联功效的代码段。
函数能坚实利用的模块性,和代码的重新利用率。你已经领悟Python提供了成都百货上千内建函数,举个例子print()。但您也能够友善创办函数,那被誉为顾客自定义函数。

—恢复生机内容初步—

一、 定义函数

概念三个函数要采用```**def````**语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。如果没有return语句,函数执行完毕后也会返回结果,只是结果为None`。。

def add(a,b):
  return a+b
print add(1,2)

概念空函数能够用pass

def nop():
    pass

概念函数时,必要规定函数名和参数个数;

假使有不能缺少,能够先对参数的数据类型做检查,数据类型检查能够用内置函数isinstance实现.

一、 定义函数

概念二个函数要使用```**def````**语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。如果没有return语句,函数执行完毕后也会返回结果,只是结果为None`。。

def add(a,b):
  return a+b
print add(1,2)

概念空函数能够用pass

def nop():
    pass

概念函数时,须求鲜明函数名和参数个数;

假若有须要,能够先对参数的数据类型做检查,数据类型检查能够用内置函数isinstance实现.

 

  1. 函数

二、函数再次来到值

函数体内部能够用return随时重回函数结果;

函数实践实现也没有return语句时,自动return None

函数能够同一时候重返多少个值,实质上正是贰个tuple。

def test(a,b,rank):
  c=a+rank
  d=b+rank
  return c,d

c,d=test(2,3,5)
print c
print d

t=test(5,10,1)
print t

二、函数再次来到值

函数体内部能够用return每八日再次回到函数结果;

函数试行完结也远非return语句时,自动return None

函数能够相同的时候再次来到三个值,实质上便是一个tuple。

def test(a,b,rank):
  c=a+rank
  d=b+rank
  return c,d

c,d=test(2,3,5)
print c
print d

t=test(5,10,1)
print t

1、语法

(1) 若是想定义贰个怎么事都不做的空函数, 能够用 pass 语句,
pass语句能够用来作为占位符, 比方未来还不曾想好怎么蝎函数代码,
就足以先放两个pass, 让代码能运作起来

三、函数参数

①私下认可参数

def power(x,n=2):
  r=1
  while(n>0):
    r=r*x
    n=n-1
  return r

print power(2)
>>4

print power(2,10)
>>1024

 

设置暗中同意参数时,有几点要留意:

一是必选参数在前,暗许参数在后;

二是暗许参数必得指向不改变对象。

②可变参数

可变参数允许你传入0个或私行个参数,那几个可变参数在函数调用时自动组装为多少个tuple。定义可变参数时,须要在变量名前加星号*。

def sum(*numbers):
  s=0
  for x in numbers:
    s=s+x*x
  return s

print sum(1,2,3,4,5)
>>>55

 

假诺参数是list只怕turple时,要求调用时在变量名前加星号。

list=[1,2,3,4,5]
print sum(*list)>>>55

t=(1,2,3,4,5)
print sum(*t)>>>55

 

③关键字参数

最重要字参数允许你传入0个或私行个含参数名的参数,那些关键字参数在函数内部自行组装为多个dict。

def show(name,age,**param):
  print "name",name,"age",age,param

show('liu',20,city='beijing',job='teacher')

dic={'city':'beijing','job':'teacher','home':'hubei'}
show('zhang',30,**dic)

 

瞩目,参数定义的种种必得是:必选参数、暗中认可参数、可变参数和要紧字参数。

④总结

暗中同意参数必须要用不可变对象,假使是可变对象,运维会有逻辑错误!

要静心定义可变参数和关键字参数的语法:

  • *args是可变参数,args接收的是一个tuple;
  • **kw是第一字参数,kw接收的是二个dict。

调用函数时怎么着传播可变参数和注重字参数的语法:

可变参数不只能够直接传入:func(1, 2, 3),又有啥不可先组装list或tuple,再经过*args传入:func(*(1, 2, 3))

重要字参数不仅能够直接传入:func(a=1, b=2),又有什么不可先组装dict,再通过**kw传入:func(**{'a': 1, 'b': 2})

三、函数参数

①暗许参数

def power(x,n=2):
  r=1
  while(n>0):
    r=r*x
    n=n-1
  return r

print power(2)
>>4

print power(2,10)
>>1024

 

设置暗中认可参数时,有几点要注意:

一是必选参数在前,私下认可参数在后;

二是暗许参数必需指向不改变对象。

②可变参数

可变参数允许你传入0个或自由个参数,那个可变参数在函数调用时自动组装为二个tuple。定义可变参数时,须求在变量名前加星号*。

def sum(*numbers):
  s=0
  for x in numbers:
    s=s+x*x
  return s

print sum(1,2,3,4,5)
>>>55

 

假设参数是list或许turple时,必要调用时在变量名前加星号。

list=[1,2,3,4,5]
print sum(*list)>>>55

t=(1,2,3,4,5)
print sum(*t)>>>55

 

③关键字参数

要害字参数允许你传入0个或自由个含参数名的参数,这几个重要字参数在函数内部自行组装为一个dict。

def show(name,age,**param):
  print "name",name,"age",age,param

show('liu',20,city='beijing',job='teacher')

dic={'city':'beijing','job':'teacher','home':'hubei'}
show('zhang',30,**dic)

 

小心,参数定义的相继必需是:必选参数、暗许参数、可变参数和关键字参数。

④总结

暗中认可参数必须求用不可变对象,假诺是可变对象,运维会有逻辑错误!

要细心定义可变参数和要害字参数的语法:

  • *args是可变参数,args接收的是贰个tuple;
  • **kw是首要字参数,kw接收的是三个dict。

调用函数时怎么传播可变参数和主要字参数的语法:

可变参数既可以够直接传入:func(1, 2, 3),又足以先组装list或tuple,再经过*args传入:func(*(1, 2, 3))

入眼字参数不只能够一贯传入:func(a=1, b=2),又能够先组装dict,再通过**kw传入:func(**{'a': 1, 'b': 2})

Python 定义函数使用 def 关键字,一般格式如下:

def nop():
    pass 

四、无名函数

python中动用lambda关键字定义无名函数的.

比如:将字符串集结成分遵照长度进行排序.

s=['hello','World','aa']
s.sort(key=lambda x:len(x))
print s

运行结果:['aa', 'hello', 'World']

 

四、无名氏函数

python中使用lambda关键字定义佚名函数的.

比如说:将字符串集结成分遵照长度举办排序.

s=['hello','World','aa']
s.sort(key=lambda x:len(x))
print s

运行结果:['aa', 'hello', 'World']

 

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

(2) 调用函数时 ,假诺参数个数不对, python解释器会自动物检疫查出来,
并抛出TypeError, 但是一旦参数类型不对, python就不可能帮大家检查.
因而得以遵照须要适宜抬高级参照他事他说加以考察数检查, 增添了参数检查后,
固然传入错误的参数类型, 函数就可以抛出三个荒谬

五、函数柯里化

函数柯里化就是平素函数的多少个参数,进而泛化出多少个例外含义的函数。那供给使用内置的functools模块的partial函数。举例:

from functools import partial

def addNumber(a,b):
    return a+b

addNumber10=partial(addNumber,10)
addNumber20=partial(addNumber,20)

print addNumber10(100) #运行结果110
print addNumber20(100)#运行结果120

 如需转发,请标记原来的书文链接:

五、函数柯里化

函数柯里化就是定位函数的多少个参数,进而泛化出八个不等含义的函数。那亟需选拔内置的functools模块的partial函数。譬喻:

from functools import partial

def addNumber(a,b):
    return a+b

addNumber10=partial(addNumber,10)
addNumber20=partial(addNumber,20)

print addNumber10(100) #运行结果110
print addNumber20(100)#运行结果120

 

一、 定义函数
定义四个函数要运用 def 语句,依次写出函数名、括号、括号中的参数和冒号 :
,然后,在缩进块…

 

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

暗中同意情形下,参数值和参数名称是按函数注明中定义的的相继相配起来的。

(3) 函数能够回来多个值, 但其实只是一种假象,
python函数重回的骨子里是八个tuple. 但是在语法上,
重回二个tuple能够省略括号, 而多少个变量能够何况接收叁个tuple,
按职务予以对应的值, 所以, python的函数重返多值其实正是回去二个tuple,
不过写起来更便于

概念八个由本人想要功效的函数,以下是粗略的条条框框:

(4) 函数实行完结也尚未return语句时, 自动return None

  • 函数代码块以 def
    关键词最早,后接函数标志符名称和圆括号 ()。
  • 其他传入参数和自变量必需放在圆括号中间,圆括号之间能够用来定义参数。
  • 函数的率先行语句能够选拔性地选择文书档案字符串——用于贮存函数表明。
  • 函数内容以冒号伊始,况兼缩进。
  • return [表达式]
    截至函数,选用性地回到四个值给调用方。不带表明式的return也正是重返None。

(5) 练习: 定义贰个函数quadratic(a,b,c), 接收3个参数,
重回一元三次方程ax^2 + bx +c = 0的三个解, 总计平方根能够调用math.sqrt()
函数:

 

 import math
 def quadratic(a, b, c):
     if a == 0:
         return -b/c
     tmp = b**2 - 4*a*c
     if tmp < 0:
         print('无解')
         return
     else:
         x1 = (-b + math.sqrt(tmp)) / (2 * a)
         x2 = (-b - math.sqrt(tmp)) / (2 * a)
         return x1,x2

 print(quadratic(2, 3, 1))
 print(quadratic(1, 3, -4))

实例:

 

def hello():
    return 'Hello world'

def say(msg):
    print(msg)

def sun(num1, num2):
    print('num1 + num2 =', num1, num2)
  1. 函数的参数

 

(1) 地点参数: 必须传入的参数

2、函数调用

#计算x的平方的函数  位置参数
def power(x):
    return x * x

Python内置了众多立见功能的函数,大家得以一直调用。要调用二个函数,供给驾驭函数的名号和参数,比如求相对值的函数abs,只有三个参数:

(2) 私下认可参数 : 暗许参数必须指向不改变对象str None那样的

print('100的绝对值:', abs(100))
print('-20的绝对值:', abs(-20))
#位置参数 x的n次方
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

如上代码,输出:

(3) 可变参数 : 传入的参数个数是可变的, 能够是1个, 2个 n个.
定义可变参数和定义贰个list或tuple参数比较,仅仅在参数前面加了三个 * 号.
这么些可变参数在函数调用时自动组装为一个tuple

100的绝对值: 100
-20的绝对值: 20
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
print(calc(1, 2))
print(calc(1, 2 , 3))

概念贰个函数:给了函数二个名号,钦定了函数里含有的参数,和代码块结构。
那些函数的骨干组织产生之后,你能够透过另三个函数调用推行,也可以一贯从
Python 命令提示符实行。

在函数内部, 参数numbers接收到的是多个tuple

3、参数字传送递 

借使已经有了二个list或然tuple,要调用多少个可变参数,
 python允许在list或tuple前边加一个*号,
把list或tuple的成分变为可变参数字传送进去:

在 python 中,类型属于对象,变量是从未项指标:

>>> nums = [1, 2, 3]
>>> calc(*nums)
14
a=[1,2,3]

a="Python"

(4) 关键字参数 : 关键字参数在函数调用时,
那么些根本字参数在函数内部自行组装为叁个dict

如上代码中,[1,2,3] 是 List 类型,”Python” 是 String 类型,而变量 a
是未有项目,它独自是几个目的的援用(三个指南针),能够是 List
类型对象,也足以针对 String 类型对象。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

 

重在字参数能够扩充函数的功用. 比方, 在person函数里,
大家保险能接到到name和age那三个参数, 但是, 若是调用者愿意提供更多的参数,
我们也能收到. 

python 函数的参数字传送递:

和可变参数近似, 也能够创立出壹个dict, 然后把该dict转变为十分重要字参数字传送进去

  • 不得变类型:类似 c++ 的值传递,如
    整数、字符串、元组。如fun(a),传递的只是a的值,未有影响a对象自己。例如在
    fun(a)内部修改 a 的值,只是修改另八个复制的指标,不会影响 a 自身。
  • 可变类型:类似 c++ 的援引传递,如 列表,字典。如 fun(la),则是将
    la 真正的传过去,修改后fun外界的la也会受影响
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

python
中一切都以对象,严厉意义大家不可能说值传递还是援引传递,大家应有说传不可变对象和传可变对象。

细心: 传进去的参数, 函数内部得到是一份拷贝!!!!

 

(5) 命名关键字参数 : 对于重大字参数, 倘诺要要限量传入的机要字参数的名字,
能够用命名第一字参数

怎样是可改动(mutable)与不足退换(immutable)对象?

def person(name, age, *, city, job):
    print(name, age, city, job)

在 python 中,str, tuple, 和 number 是不行改换的目的,而 list,dict
等则是能够修改的靶子。例如:

和重大字参数**kw分化, 命名关键字参数需求三个特种分隔符*,
*末尾的参数被视为命名首要字参数

不可变类型:变量赋值 a=5 后再赋值 a=10,这里实在是新兴成三个 int 值对象
10,再让 a 指向它,而 5 被撇下,不是改动a的值,也正是新生成了a。

要是函数定义中早已有了一个可变参数,
前面跟着的命名第一字参数就不在要求三个别树一帜分隔符*了

可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la
的第五个成分值更换,本人la未有动,只是其内部的一部分值被修改了。

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

 

 命名关键字参数必需传入参数名, 那一个任务参数分歧, 若无传来参数名,
调用将报错

不可变对象在函数里修改了参数,原始的参数是不会转移的。比方:

(6) 参数组合

def ChangeInt(a):
    a = 10

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

在python中定义函数, 能够用必需参数, 私下认可参数,
关键字参数和命名首要字选择数, 那第55中学参数都能够构成使用, 可是请留神,
参数定义的顺序必需是 : 必选参数, 默许参数, 可变参数, 命名关键字参数,
关键字参数

实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt
函数时,按传值的措施复制了变量 b,a 和 b 都指向了同贰个 Int 对象,在
a=10 时,则新生成三个 int 值对象 10,并让 a 指向它。

 

 

  1. 递归函数

可变对象在函数里修改了参数,那么原本的参数也被改造了。举个例子:

(1) 使用递归函数须求留神防卫栈溢出, 在电脑中,
函数调用是透过栈这种数据结构达成, 每当踏入四个函数调用,
栈就能够加一层栈帧, 每当函数再次来到, 栈就能够减一层栈帧.
由于栈的大小不是不过的, 所以, 递归调用的次数过多, 会导致栈溢出.

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


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

(2) 化解递归调用栈溢出的艺术是透过尾递归优化.

流传函数的和在最终增添新内容的指标用的是同三个援引。故输出结果如下:

(3) 尾递归是指, 在函数再次来到的时候, 调用小编本身, 並且,
return语句无法包括表达式,
那样编写翻译器可能解释器就可以把尾递归做优化吗使递归自身无论调用多少次,
都只占用三个栈帧, 不会冒出栈溢出的情事

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

(4) 近些日子好些个编制程序语言没有对准尾递归做优化, python解释器也未曾做优化.

 

# 利用递归函数移动汉诺塔:
def move(n, a, b, c):
    if n == 1:
        print('move', a, '-->', c)
        return
    move(n-1, a, c, b)
    print('move', a, '-->', c)
    move(n-1, b, a, c)

move(4, 'A', 'B', 'C')

4、参数

 

  • 必备参数
  • 重视字参数
  • 默许参数
  • 不定长参数

 

 

怎样是须要参数?必得参数须以科学的次第传入函数。调用时的数据必得和评释时的同一。下边包车型大巴实例中调用say()函数,你无法不传入三个参数,否则会现出语法错误:

def say(msg):
    print(msg)  # 打印传入的参数

#调用say
say('hello world')

如上代码,输出:

hello world

但,大家如下调用时,就能够报错:

def say(msg):
    print(msg)  # 打印传入的参数

#调用say
say()

上述代码,报错:

TypeError: say() missing 1 required positional argument: 'msg'

调用函数的时候,假使传入的参数数量不对,会报TypeError的荒谬,并且Python会明确地告知你。

 

万一传入的参数数量是对的,但参数类型无法被函数所接受,也会报TypeError的谬误,而且付诸错误音讯:str是不对的参数类型:

print(abs('abc'))

如上代码,会报错:

TypeError: bad operand type for abs(): 'str'

 

怎么样是重大字参数?关键字参数和函数调用关系密不可分,函数调用使用紧要字参数来规定传入的参数值。使用首要字参数允许函数调用时参数的依次与证明时不一样样,因为
Python 解释器能够用参数名相称参数值。

我们来看实例:

#  申明一个函数say,第一个参数为:name,第二个参数为:msg
def say(name, msg):
    print('%s 说:%s' %(name, msg))  # 打印传入的参数

# 普通方式调用say()
say('roy', 'hello world')

# 用关键字参数的方式调用say()
say(msg='这是用关键字参数的方式调用的', name='roy')

如上代码,输出:

roy 说:hello world
roy 说:这是用关键字参数的方式调用的

我们得以看到,在其次次调用的时候,大家一直未有遵从函数注明时的参数顺序去传递参数,但也是未可厚非的输出了内容。

 

什么样是默许参数?调用函数时,若无传递参数,则会选拔私下认可参数。以下实例中只要未有传到
msg 参数,则动用暗中同意值:

#  申明一个函数say,第一个参数为:name,第二个参数为:msg
def say(name, msg='hello world'):
    print('%s 说:%s' %(name, msg))  # 打印传入的参数

# 调用
say('roy')

上述代码,输出:

roy 说:hello world

设置私下认可参数时,有几点要细心:

一是必选参数在前,暗许参数在后,不然Python的解释器会报错(思索一下为何私下认可参数无法放在必选参数后边);

二是什么样设置暗中同意参数。当函数有四个参数时,把变化大的参数放前边,变化小的参数放前面。变化小的参数就可以看作默许参数。

 

怎么样是不定长参数?你或者要求贰个函数能管理比当下表明时越多的参数。那一个参数叫做不定长参数,和上述两种参数分化,证明时不会取名。基本语法如下:

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

加了星号(*)的变量名会寄放全数未命名的变量参数。假使在函数调用时从没点名参数,它就是三个空元组。我们也可以不向函数字传送递未命名的变量。如下实例:

# 可写函数说明
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

 

摸底了那多种参数的款型了,大家来讲下另一种参数字传送递的办法:分拆参数列表

比方说,内建的range()函数期待单独的startstop参数。假诺它们没办法独立地赢得,能够编写制定带有*操作的函数调用,来从一个列表或元组分拆出参数:

print(list(range(0, 3)))

args = [0, 3]
print(list(range(*args)))  # range(*args) 等价于 range(0, 3)

上述代码,输出:

[0, 1, 2]
[0, 1, 2]

你会意识,range(*args) 等价于 range(0,
3),在上例中列表中的第多少个要素被传送给了range()函数的第贰个参数,第三个成分被传送给了函数的第二个参数。要留神的是,列表里的要素个数必得和函数必需参数的个数对应

 

无差距于的品格,字典能够因而**操作传递关键字参数:

def parrot(voltage, state='a stiff', action='voom'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.", end=' ')
    print("E's", state, "!")

d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}

parrot(**d)

上述代码,输出:

-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

你会意识,字典的key会对照函数的参数,一一把key对应的value传入给函数

 

5、佚名函数

python 使用 lambda 来创造无名氏函数。

所谓无名,意即不再选拔 def 语句那样规范的款式定义一个函数。

  • lambda 只是一个表明式,函数体比 def 简单非常多。
  • lambda的宗旨是三个表明式,实际不是一个代码块。仅仅能在lambda表明式中封装有限的逻辑进去。
  • lambda
    函数具有自身的命名空间,且不能够访问自身参数列表之外或全局命名空间里的参数。
  • 纵然lambda函数看起来只可以写一行,却分化样C或C++的内联函数,前者的指标是调用小函数时不占用栈内部存款和储蓄器进而扩大运转作用。

lambda 函数的语法只含有八个口舌,如下:

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

实例:

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

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

如上代码,输出:

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

 

多少时候,当大家在流传函数时,不须求显式地定义函数,直接传入无名氏函数更方便人民群众。无名函数有个限制,就是不得不有二个表明式,无需写return,重返值就是该表明式的结果。用佚名函数有个实惠,因为函数没盛名字,不必忧虑函数名争持。其它,佚名函数也是二个函数对象,也足以把佚名函数赋值给贰个变量,再使用变量来调用该函数

 

6、return语句

return [表达式]
语句用于退出函数,选用性地向调用方重回三个表明式。不带参数值的return语句重返None。

实例:

#  这是一个有return语句的函数
def hello():
    return 'Hello world'

#  这是一个有return语句的函数,默认返回None
def say(msg):
    print(msg)

#  调用 hello 并把它的结果赋值给 变量
msg = hello()
print(msg)

# 调用 say
say('您好')

上述代码,输出:

Hello world
您好

 

 

7、注释

函数的第一行语句能够选拔性地接纳文书档案字符串——用于存放函数表达,比方:

def test():
    """
    this is test
    :return: int string
    """
    return 1

能够调用 __doc__ 查看函数的文书档案:

def test():
    """
    this is test
    :return: int string
    """
    return 1

print(test.__doc__)

以上代码,输出:

    this is test
    :return: int string

 

在python3中你还是能这样为函数增添注释:

def dog(name:str, age:(1, 99), species:'狗狗的品种') -> tuple:
    return (name, age, species)

如上,能够使用:对参数每一个举办表明,注释内容能够是其他方式,举个例子参数的种类、成效、取值范围等等,再次回到值使用->标记,全数的注释都会保留至函数的属性。

翻看这个注释能够通过 __annotations__ 获取,结果会议字典的款式重回:

def dog(name:str, age:(1, 99), species:'狗狗的品种') -> tuple:
    return (name, age, species)


print(dog.__annotations__)

如上代码,输出:

{'name': <class 'str'>, 'age': (1, 99), 'species': '狗狗的品种', 'return': <class 'tuple'>}

另外,使用函数注释并不影响暗中同意参数的使用:

def dog(name:str ='dobi', age:(1, 99) =3, species:'狗狗的品种' ='Labrador') -> tuple:
    return (name, age, species)

print(dog())

如上代码,输出:

('dobi', 3, 'Labrador')

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图