标签：test   bsp   --   return   依赖   本质   line   class   sans   

初识函数

内置函数
自定义函数
　　

定义无参函数           #只打印执行语句的时候
def foo():
    print(‘from the foo‘)
# print(foo.__doc__)   #查看函数的文档注释

定义有参函数     #依赖外部传来的值的时候
def bar(x,y):
    print(x)
    print(y)

定义空函数    #程序开发阶段经常使用，写程序框架的时候
def auth():
    pass

函数的参数

函数的参数介绍
形参和实参的概念

def foo(x,y): #在函数定义阶段，括号内定义的参数-》形式参数----》本质就是变量名
    print(x)  #形式参数可以定义参数的类型(x:int,y:int)
    print(y)

foo(1,2) #在函数调用阶段，括号内定义的参数-》实际参数-->实参必须要有一个明确的值，可被当成变量值 

函数的参数传值

def foo(x,y):
    print(x)
    print(y)

在实参的角度

第一种：按照位置传值
foo(1,2)

第二种：按照关键字传值
foo(x=1,y=2)

第三种：混着用
foo(1,y=2)
问题一：按位置传值必须在按关键字传值的前面
foo(y=2,1) #报错
问题一：对于一个形参只能赋值一次

从形参的角度来分析

位置参数：必须传值的参数
def foo(x,y):
    print(x)
    print(y)

foo(1,2)

默认参数
def foo(x,y=1):
    print(x)
    print(y)

foo(1)

默认参数注意：
一、

def register(sex=‘male‘,name): 
#报错,默认参数必须注意的问题是：默认参数必须放到位置参数的后面
    print(name)
    print(sex)
register()
register(‘qinzhen‘)
二、

x=‘male‘
def register(sex=x): #register（sex=‘male‘）

    print(sex)     　#sex="male"
x=None
register()

#结果为male

再举一列

不推荐下述方式
x=[]
def register(name,name_list=x): #
    name_list.append(name)
#------------------------------------------------
register(‘ASB‘)
register(‘YSB‘)
register(‘WSB‘)
print(x)

#结果为[‘ASB‘, ‘YSB‘, ‘WSB‘]

*args

*args位置参数传值后剩下的装入元组

def foo(x,*args): #args=(2, 3, 4, 5, 6, 6, ‘a‘, ‘b‘)
    print(x)
    print(args)
foo(1,2,3,4,5,6,6,‘a‘,‘b‘)
#结果为

1
(2, 3, 4, 5, 6, 6, ‘a‘, ‘b‘)

*args与位置参数和默认参数混用:*args要放到位置参数后面
def foo(x,*args,y=1):
    print(x)
    print(y)
    print(args)

foo(1,2,3,4,5,6,7,8,9,10,y=10000000)
结果为：

1
10000000
(2, 3, 4, 5, 6, 7, 8, 9, 10)

从形参的角度
def foo(*args):  #foo(1,2,3)
    print(args)

foo(1,2,3)

从实参的角度
def bar(x,y,z):
    print(x)
    print(y)
    print(z)
bar(*(1,2,3)) #bar(1,2,3)

**kwargs

按关键字传值剩下的装入字典

def foo(x,**kwargs):
    print(x)
    print(kwargs)

foo(1,y=1,z=2)
结果为：
   1
   {‘y‘: 1, ‘z‘: 2}

*args,**kwargs混着用的位置问题

def foo(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)

foo(1,y=1,z=2)    
结果  1   （）  {"z":2,"y":1}

从形参的角度
def foo(**kwargs): #x=1,y=2,z=3
    print(kwargs)

foo(x=1,y=2,z=3)

从实参的角度
def foo(x,y,z=1):
    print(x)
    print(y)
    print(z)

foo(**{‘x‘:1,‘y‘:2,‘z‘:3})  #foo(x=1,y=2,z=2)
foo(**{‘x‘:1,‘y‘:2})  #foo(x=1,y=2)
foo(**{‘a‘:1,‘y‘:2})  #foo(a=1,y=2)   #报错，没有a参数

函数的调用形式

def foo():#无参函数一般执行语句
    print(‘from the foo‘)


def bar(x,y):#有参函数一般要求有返回值
    res=x+y
    return res

函数的调用

foo() #函数调用的语句形式
res=bar(1,2) #函数调用的表达式形式 
res1=bar(1,2)*10 #函数调用的表达式形式
res2=bar(bar(1,2),3) #函数的调用作为另外一个函数的参数
print(res)
print(res1)
print(res2)

函数的返回值

函数的返回值可以是任意类型
没有return--->None
return 1--->1
return 1,2,3--->(1,2,3)

def test():
    return 1  #只会返回第一个return值
    print(‘--------------‘)
    print(‘--------------‘)
    return 2
    return 3

res=test()
print(res)

#结果为 1

初识函数、函数的参数、函数的参数传值、函数的调用形式、函数的返回值

标签：test   bsp   --   return   依赖   本质   line   class   sans   

原文地址：http://www.cnblogs.com/domestique/p/6752315.html