第八6章

ca88会员登录中心 4
ca88会员登录中心

python基础(二):

菜鸟教程基础知识讲解的非常全面,内容选择我认为的重点输出一遍

一 为何要有函数?

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。

函数:

不加区分地将所有功能的代码垒到一起,问题是:

 

定义一个函数:

你可以定义一个由自己想要功能的函数,以下是简单的规则:

  

def fun(arg):
    pass
    return arg

# 函数调用语法
fun(arg)
  • arg:argument,参数(也叫prarmeter)
    ,任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
  • def:define,定义,创建函数
    ,函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()
  • 代码缩进表示语句块,表明代码从属关系
  • return
    [表达式]
     结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回
    None。

 

 

  代码可读性差
  代码冗余
  代码可扩展差

1、语法

函数的调用:

  将参数传入已经定义好的函数中,便可以调用此函数

def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return

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

以上实例输出结果:
我要调用用户自定义函数!
再次调用同一函数

 

 

如何解决?
  函数即工具,事先准备工具的过程是定义函数,拿来就用指的就是函数调用

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

函数返回值:

  • 所谓“返回值”,就是程序中函数完成一件事情后,最后给调用者的结果

  • #定义函数

        def add2num(a, b):
            return a+b
    
        #调用函数,顺便保存函数的返回值
        result = add2num(100,98)
    
        #因为result已经保存了add2num的返回值,所以接下来就可以使用了
        print (result) --->198
    

    函数返回值可以为多个:

  • def divid(a, b):

    ... shang = a//b
    ... yushu = a%b 
    ... return shang, yushu
    ...
    >>> sh, yu = divid(5, 2)
    >>> sh
    5
    >>> yu
    1
    

  结论:函数使用必须是:先定义,后调用

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

 

python中函数定义方法:

 

 

    def test(x):
    ”The function definitions”
    x+=1
    return x

默认情况下,参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

4种函数的类型:

函数根据有没有参数,有没有返回值,可以相互组合,一共有4种

  • 无参数,无返回值

    •   

      # 函数定义,初级
      def numsum():
          a = 5
          b = 10
          c = a + b
          print(c)
      
      # 函数执行
      numsum() --->15
      

       

  • 无参数,有返回值

  • 有参数,无返回值

  • 有参数,有返回值

    • 输入参数:

      • 形参:形式参数,声明函数时,括号()中的参数
      • 实参:实际参数,调用函数是,括号()中的参数
      • 实参将值传给形参,本质上是变量赋值
      • 返回值:return

        • 会终止函数执行(return是函数的最后一句),并返回一个值给调用方
        • 不带表达式的return返回None
        • Print()不是返回值,只是输出信息到界面
        • # 函数定义,带输入输出

          def numsum2(a, b):
              c = a + b
              return c
          
          # 函数调用
          d = numsum2(10, 20)
          print(d)  --->30
          

           

  def:定义函数的关键字
  test:函数名
  ():内可定义形参
  ””:文档描述(非必要,但是强烈建议为你的函数添加描述信息)
  x+=1:泛指代码块或程序处理逻辑
  return:定义返回值

定义一个由自己想要功能的函数,以下是简单的规则:

函数中参数的类别:

  • 必需参数

    •   

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

       

  • 关键字参数

    •   

      def about(name,course,site):
          print (name,course,site)
      
      about(site='www.baidu.com',name='green',course=100)   ##以关健字方式传入参数(可以不按顺序)
      
     
  • 默认参数

    •   

      def about(name,course,site):
          print (name,course,site)
      
      about('jim','100','www.baidu.com')   ## 必须按顺序传参
      

       

  • 不定长参数

    •   

      • 非关键字可变参数(元组)

        • 放在默认值参数后面
        • 可将传入的不确定数量的默认参数聚合为元组方便函数使用
        • def fun(a, b, *args):

              print(a)
              print(b)
              print(args)
              print("="*30)
              ret = a + b
              for i in args: #便利args中的元素
                  ret += i
              return ret
          
          print(fun(1,2,3,4))
          
          结果:
          1
          2
          (3, 4)
          ==============================
          10
          

           

      • 关键字可变参数(字典)

        • 放在非关键字可变参数后面
        • 可将传入的不确定数量的默认值参数聚合为字典方便函数使用
        • def fun(a, b, *args, **kwargs):

              print(a) 
              print(b)
              print(args)
              print(kwargs)
          
          fun(1, 2, 3, 4, name = "hello", age = 20)
          
          结果:
          1
          2
          (3, 4)
          {'name': 'hello', 'age': 20}
          

尽量避免多种参数格式混合(主要是两种可变参数)
多参数混合时注意顺序:
    一般顺序是:默认参数,默认值参数,非关键字可变参数,关键字可变参数
    注意:带关键字的参数必须放在最后

调用运行:可以带参数也可以不带
函数名()

  • 函数代码块以 def
    关键词开头,后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串——用于存放函数说明。
  • 函数内容以冒号起始,并且缩进。
  • return [表达式]
    结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回
    None。

匿名函数:

  • 语义上讲,lambda
    只是普通函数定义中的一个语法技巧,书写代码更简洁(但不易懂)
  • lambda 是一个表达式(非代码块),比 def 简单,仅能封装有限的逻辑如if
    else分支,不能使用多项分支和循环,不适合复杂操作

    # 普通函数
    def def_sum(a, b):

    return a + b
    

    def_sum(5, 10)

    # 匿名函数:变量名 = lambda 参数… : 表达式计算
    lambda_sum = lambda a, b: a + b
    lambda_sum(5, 10)

    —>15

    分支匿名函数

    # 普通函数
    def def_gender(g):

    if g == 1:
        return '男性'
    else:
        return '女性'
    

    def_gender(0)

    # 匿名函数:变量名 = lambda 参数… : 分支1的值 if 判断条件 else 分支2的值
    lambda_gender = lambda a: ‘男性’ if a == 1 else ‘女性’
    lambda_gender(1)
    —>男性

    # 普通函数
    def absum(a, b):

    return a + b
    

    ca88会员登录中心,def def_sum2(a, b, c):

    return absum(a, b) + c
    

    def_sum2(1,2,3)

    # 匿名函数:变量名 = lambda 参数… : 其他函数组成的表达式
    def absum(a, b):

    return a + b
    

    lambda_sum = lambda x, y, z: absum(x, y) + z
    lambda_sum(1,2,3)

    —>6

 

 

匿名函数练习题:

将列表内的字典按照年龄进行排序:
infors = [{'name':'laowang','age':23},{'name':'ab','age':34},{'name':'bf','age':43}]

 

 

 

二:函数的分类

实例:

  1.内置函数:built-in
  2.自定义函数:
    def 函数名(参数1,参数2,…):
      ”’注释”’
      函数体

def hello():
    return 'Hello world'

def say(msg):
    print(msg)

def sun(num1, num2):
    print('num1 + num2 =', num1, num2)

函数的使用:先定义,后调用
如何定义函数之定义函数的三种形式
1
定义无参函数
:函数的执行不依赖于调用者传入的参数就能执行时,需要定义为无参函数

 

def print_tag():
print(‘*************************’)

2、函数调用

def main():
print_tag(‘*’,20,3)
print_msg(‘hello world’)
print_tag(‘*’,20,3)

Python内置了很多有用的函数,我们可以直接调用。要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数abs,只有一个参数:

main()

print('100的绝对值:', abs(100))
print('-20的绝对值:', abs(-20))

2
定义有参数
:函数的执行需要依赖于调用者传入的参数才能执行时,需要定义为有参函数

以上代码,输出:

def print_tag(tag,count,line_num):
for i in range(line_num):
print(tag*count)

100的绝对值: 100
-20的绝对值: 20

3 定义空函数:函数体为pass

定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从
Python 命令提示符执行。

def func(x,y,z):
pass

3、参数传递 

三:函数的使用原则
  函数的使用必须遵循:先定义后使用的原则
  函数的定义,与变量的定义是相似的,如果没有事先定义函数而直接引用就相当于在引用一个不存在变量名  

在 python 中,类型属于对象,变量是没有类型的:

#定义阶段:只检测语法,不执行代码

a=[1,2,3]

a="Python"

def func():
if 1>2
print(‘hahahahahahah’)
def func():
      #语法没问题,逻辑有问题,引用一个不存在的变量名
asdfasdfasdfasdfasdf

以上代码中,[1,2,3] 是 List 类型,”Python” 是 String 类型,而变量 a
是没有类型,它仅仅是一个对象的引用(一个指针),可以是 List
类型对象,也可以指向 String 类型对象。

#调用阶段

 

foo()

python 函数的参数传递:

返回值:可以返回任意类型

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

没有return:None
return value: value
return val1,val2,val3 :(val1,val2,val3)

python
中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。

return的效果:只能返回一次值,终止函数的执行

 

返回值:

什么是可更改(mutable)与不可更改(immutable)对象?

   返回值数=0:返回None

在 python 中,str, tuple, 和 number 是不可更改的对象,而 list,dict
等则是可以修改的对象。例如:

   返回值数=1:返回object

不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象
10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。

   返回值数>1:返回tuple

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

四:函数参数

 

ca88会员登录中心 1

不可变对象在函数里修改了参数,原始的参数是不会改变的。例如:

1.形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

def ChangeInt(a):
    a = 10

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

2.实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使参数获得确定值

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

3.位置参数和关键字(标准调用:实参与形参位置一一对应;关键字调用:位置无需固定)

 

4.默认参数

可变对象在函数里修改了参数,那么原始的参数也被改变了。例如:

5.参数组

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


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

函数参数分类:

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

 1、位置参数(形参、实参)

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

位置参数:按照从左到右的顺序依次定义的参数
  def foo(x,y):
  print(x)
  print(y)
按位置定义的形参,必须被传值,多一个不行,少一个也不行
  foo(1,2,3)===>报错
按位置定义的实参,与形参一一对应
  foo(2,10)

 

2、关键字参数 (实参)

4、参数

关键字参数:实参在定义时,按照key=value形式定义
  def foo(x,y):
  print(x)
  print(y)
  # foo(y=10,x=1)
  foo(y=10,x=1)
#关键字参数可以不用像位置实参一样与形参一一对应,指名道姓地传值

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

  #  foo(1,z=20,10)  
===>报错

 

  # foo(1,y=2,z=10)
 
===>报错**

什么是必需参数?必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。下面的实例中调用say()函数,你必须传入一个参数,不然会出现语法错误:

注意的问题一:位置实参必须在关键字实参的前面
注意的问题二:实参的形式既可以用位置实参又可以是关键字实参,但是一个形参不能重复传值

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

#调用say
say('hello world')

 3、默认参数(形参)

以上代码,输出:

默认参数:在定义函数阶段,就已经为形参赋值,定义阶段有值,调用阶段可以不用传值

hello world

定义:

但,我们如下调用时,就会报错:

# def func(x,y=10):
# print(x)
# print(y)

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

#调用say
say()

调用:

以上代码,报错:

# func(1,20)
# func(1)

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

# def func(y=10,x):
# print(x)
# print(y)

调用函数的时候,如果传入的参数数量不对,会报TypeError的错误,并且Python会明确地告诉你。

 形参的应用:值经常变化的需要定义成位置形参,值大多数情况下都一样,需要定义成默认参数

 

默认参数需要注意的问题一:必须放在位置形参后面
默认参数需要注意的问题二:默认参数通常要定义成不可变类型
默认参数需要注意的问题三:默认参数只在定义阶段被赋值一次

如果传入的参数数量是对的,但参数类型不能被函数所接受,也会报TypeError的错误,并且给出错误信息:str是错误的参数类型:

4、可变长参数

print(abs('abc'))

可变长参数:可变长指的是实参的个数不固定

以上代码,会报错:

按位置定义的非关键字可变长度的实参:*     *args

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

按关键字定义的可变长度的实参:**        **kwargs

 

非关键字可变长度的实参:*

什么是关键字参数?关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为
Python 解释器能够用参数名匹配参数值。

定义一个函数的时候,必须要预先定义这个函数需要多少个参数(或者说可以接受多少个参数)。一般情况下这是没问题的,但是也有在定义函数的时候,不能知道参数个数的情况(想一想C语言里的printf函数),在Python里,带*的参数就是用来接受可变数量参数的。看一个例子

我们来看实例:

def funcD(a, b, *c):
  print a
  print b
  print “length of c is: %d ” % len(c)
  print c
调用funcD(1, 2, 3, 4, 5, 6)结果是
1
2
length of c is: 4
(3, 4, 5, 6)

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

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

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

  前面两个参数被a、b接受了,剩下的4个参数,全部被c接受了,c在这里是一个tuple。我们在调用funcD的时候,至少要传递2个参数,2个以上的参数,都放到c里了,如果只有两个参数,那么c就是一个empty
tuple。

以上代码,输出:

 

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

 关键字定义的可变长度的实参:**

我们可以看出,在第二次调用的时候,我们根本没有按照函数申明时的参数顺序去传递参数,但也是正确的输出了内容。

  如果一个函数定义中的最后一个形参有 **
(双星号)前缀,所有正常形参之外的其他的关键字参数都将被放置在一个字典中传递给函数,比如:

 

def funcF(a, **b):
  print a
  for x in b:
    print x + “: ” + str(b[x])
调用funcF(100, c=’你好’, b=200),执行结果
100
c: 你好
b: 200

什么是默认参数?调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入
msg 参数,则使用默认值:

  大家可以看到,b是一个dict对象实例,它接受了关键字参数b和c。

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

# 调用
say('roy')

结合一起使用:

以上代码,输出:

# def wrapper(*args,**kwargs): #可以接受任意形式,任意长度的参数
# print(args)
# print(kwargs)
#
#
# wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)  
===>(1,2,3,3,3,3,3,)   {‘x’:1,’y’=2,’z’=3}

roy 说:hello world

命名关键字参数:定义在*后的形参,必须被传值,而且要求实参必须是以关键字的形式来传值

设置默认参数时,有几点要注意:

即:

一是必选参数在前,默认参数在后,否则Python的解释器会报错(思考一下为什么默认参数不能放在必选参数前面);

  形参:  *args,z=10

二是如何设置默认参数。当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。

或:

 

  实参:z=10

什么是不定长参数?你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述几种参数不同,声明时不会命名。基本语法如下:

# def func(x,y=1,*args,z,**kwargs):
# print(x)
# print(y)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,z=10,a=1,b=2)

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

 结果:

加了星号(*)的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例:

ca88会员登录中心 2

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


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

 

以上代码,输出:

# def func(x,*args,z=1,**kwargs):
# print(x)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,a=1,b=2,c=3)

输出: 
10
输出: 
70
60
50

 结果:

 

ca88会员登录中心 3

了解了这四种参数的形式了,我们来说下另一种参数传递的方式:分拆参数列表

 

例如,内建的range()函数期待单独的startstop参数。如果它们不能单独地获得,可以编写带有*操作的函数调用,来从一个列表或元组分拆出参数:

 总结:形参:位置形参,默认参数,*args,命名关键字参数,**kwargs

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

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

 五、函数嵌套

以上代码,输出:

#函数的嵌套调用
#
# def max2(x,y):
# if x > y:
# return x
# else:
# return y
#
# def max4(a,b,c,d):
# res1=max2(a,b) #23
# res2=max2(res1,c) #23
# res3=max2(res2,d) #31
# return res3
#
#
# print(max4(11,23,-7,31))

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

#函数的嵌套定义
def f1():
def f2():
def f3():
print(‘from f3’)
print(‘from f2’)
f3()
print(‘from f1’)
f2()
# print(f1)
f1()

你会发现,range(*args) 等价于 range(0,
3),在上例中列表中的第一个元素被传递给了range()函数的第一个参数,第二个元素被传递给了函数的第二个参数。要注意的是,列表里的元素个数必须和函数必需参数的个数对应

”’
from f1
from f2
from f3

 

”’

同样的风格,字典可以通过**操作传递关键字参数:

函数对象:

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)

ca88会员登录中心 4

以上代码,输出:

 

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

 六、命名空间

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

名字空间:存放名字与值的绑定关系

 

名称空间分为三种

5、匿名函数

  内置名称空间:python解释器自带的名字,python解释器启动就会生成

python 使用 lambda 来创建匿名函数。

  全局名称空间:文件级别定义的名字都会存放与全局名称空间,执行python文件时会产生

所谓匿名,意即不再使用 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

作用域在定义函数时就已经固定住了,不会随着调用位置的改变而改变

 

 1 name='alex'
 2 def foo():
 3     name='lhf'
 4     def bar():
 5         name='wupeiqi'
 6         print(name)
 7         def tt():
 8             name='hedeyong'
 9             print(name)
10         return tt
11     return bar
12 
13 func=foo()
14 func()()       #==> bar()() ==>tt()
  '''
  hedeyong
  '''

有些时候,当我们在传入函数时,不需要显式地定义函数,直接传入匿名函数更方便。匿名函数有个限制,就是只能有一个表达式,无需写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地图