python基础之函数(十三)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hiwoshixiaoyu/article/details/89325443

---

函数定义

定义函数的格式如下：

def 函数名():
    代码

demo:

# 定义一个函数，能够完成打印信息的功能
def printInfo():
    print ('------------------------------------')
    print ('         人生苦短，我用Python')
    print ('------------------------------------')

函数调用

printInfo()

函数的文档说明

函数的文档说明

def functionFuck(a, b):
    """Do X and return a list.
    """         # 查看 sys 模块的帮助

help(functionFuck)

函数参数

<1> 定义带有参数的函数

  def add2num(a, b):
        c = a+b
        print c

<2> 调用带有参数的函数

    def add2num(a, b):
        c = a+b
        print c

    add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据

<3> 调用函数时参数的顺序

def test(a,b):
       print(a,b)

test(1,2)
test(b=1,a=2)
test(b=1,2)

报错

关键字参数必须跟随在位置参数后面! 因为python函数在解析参数时, 是按照顺序来的, 位置参数是必须先满足, 才能考虑其他可变参数. ==

<4> 小总结

• 定义时小括号中的参数，用来接收参数用的，称为 “形参”
• 调用时小括号中的参数，用来传递给函数用的，称为 “实参”

函数返回值

<1>“返回值”介绍

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

<2>带有返回值的函数

    def add2num(a, b):
        c = a+b
        return c
#或者

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

<3>保存函数的返回值

#定义函数
    def add2num(a, b):
        return a+b

    #调用函数，顺便保存函数的返回值
    result = add2num(100,98)

    #因为result已经保存了add2num的返回值，所以接下来就可以使用了
    print result

198

<4>多返回值

#本质是利用元祖
def divid(a, b):
   shang = a//b
   yushu = a%b 
   return shang, yushu

sh, yu = divid(5, 2)
print(sh)
print(yu)

4种函数的类型

<1>无参数，无返回值的函数

<2>无参数，有返回值的函数

<3>有参数，无返回值的函数

<4>有参数，有返回值的函数

---

函数根据有没有参数，有没有返回值可以相互组合
定义函数时，是根据实际的功能需求来设计的，所以不同开发人员编写的函数类型各不相同

---

<5>缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

def printinfo( name, age = 35 ):
       # 打印任何传入的字符串
   print ("Name: ", name)
   print ("Age ", age)

# 调用printinfo函数
printinfo(name="miki" )
printinfo( age=9,name="miki" )

注意：带有默认值的参数一定要位于参数列表的最后面。

<6>不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

格式

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

demo:

#加了星号（*）的变量args会存放所有未命名的变量参数，
# args为元组；而加**的变量kwargs会存放命名参数，
# 即形如key=value的参数， kwargs为字典。
def fun(a, b, *args, **kwargs):
    """可变参数演示示例"""
    print ("a=",a)
    print ("b =", b)
    print ("args =", args)
    print ("kwargs: ")
    for key, value in kwargs.items():
           print (key, "=", value)

fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
print("---------")
c = (3, 4, 5)
d = {"m":6, "n":7, "p":8}
fun(1, 2, *c, **d)    # 注意元组与字典的传参方式
print("---------")
fun(1, 2, c, d) # 注意不加星号与上面的区别

<7>引用传参()

• 可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
• Python有没有类似C语言中的指针传参呢？

Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

def selfAdd(a):
    """自增"""
    a = a + a   # 我们更改了函数体的这句话
   
   
a_int = 1
selfAdd(a_int)
print(a_int)
a_list = [1, 2]
selfAdd(a_list)
print(a_list)

a = [100] #这里的a是一个列表，是可变类型
def test(a):
    a+=a #由于列表a是可变类型，所以这里是修改a
    print(id(a))
    print(a)

test(a)
print(id(a))
print(a)

函数的嵌套调用

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')


def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')
   
   
testA()

局部变量与全局变量

局部变量

• 局部变量，就是在函数内部定义的变量
• 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
• 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用
• 

全局变量

小总结

• 在函数外边定义的变量叫做全局变量
• 全局变量能够在所有的函数中进行访问
• 如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
• 如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧强龙不压地头蛇

---

• 此处会报错

a = 1
def f():
   a += 1
   print a

f()

• 无需global

li = [1,]
def f2():
    li.append(1)
    print (li)

f2()

[1, 1]

---

• 正确用法

a = 1
def f():
   global  a
   a += 1
   print (a)

f()

• 在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
• 对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
• 对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。

递归函数

匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句，如下：

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

如下实例：

    
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))

Value of total : 30
Value of total : 40

使用场景

函数作为参数传递

def fun(a, b, opt):
   print ("a =", a)
   print ("b =", b)
   print ("result =", opt(a, b))

fun(1, 2, lambda x,y:x+y)

a = 1
b = 2
result = 3

作为内置函数的参数

stus = [
    {"name":"zhangsan", "age":18}, 
    {"name":"lisi", "age":19}, 
    {"name":"wangwu", "age":17}
]
#按name排序
stus.sort(key = lambda x:x['name'])
print(stus)
# 按age排序
stus.sort(key = lambda x:x['age'])
print(stus)

函数使用注意事项

1.自定义函数

• 一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据
• 在开发中往往根据需求来设计函数需不需要返回值
• 函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成
• 在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收
• 参数列表中变量的个数根据实际传递的数据的多少来确定

2. 调用函数

• <1>调用的方式为：

   函数名([实参列表])

• <2>调用时，到底写不写 实参
• • 如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数
• <3>调用时，实参的个数和先后顺序应该和定义函数中要求的一致
• <4>如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值

3. 作用域

• <1>在一个函数中定义的变量，只能在本函数中用(局部变量)
• <2>在函数外定义的变量，可以在所有的函数中使用(全局变量)