Python学习笔记（十二）

Python学习笔记（十二）—函数

一、函数是什么？

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。通俗来讲函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

1 def fun():  #定义一个名称是fun的函数
2     print('hello world!')  #函数体：函数要实现的功能
3 fun()  #调用这个函数
4 
5 结果：
6 hello world!

二、函数的好处

　　1、简化程序代码

　　2、提高程序代码的复用性

　　3、代码可扩展性

三、函数的定义

Python中提供了许多内建函数，比如print函数。当然函数也可以自己创建，被叫做用户自定义函数。

函数定义的规则：

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

语法格式：　

1 def functionname( parameters ):
2    "函数_文档字符串"
3    function_suite    #函数体
4    return [expression]  #调用函数后的返回

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

实例：

1 def print_str(str):
2     '打印输出传入的字符串'
3     print('要打印的字符串是：',str)
4 print('Hello world!')
5 
6 运行结果：
7 Hello world!

四、参数传递

在Python中，类型属于对象，变量是没有类型的；比如

a = [1,2,3]

a = 'helloworld!'

如上，[1,2,3]是一个list类型， 'helloworld!'是一个string类型，而变量a是没有类型的，它仅仅是一个对象的引用（一个指针），可以是list类型对象也可以是string类型对象。

对象分为：可更改对象与不可更改对象

可更改对象：list、dicti等

不可更改对象：字符串、元祖、numbers

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

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

函数的参数传递：

　　可变类型：如列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

　　不可变类型：如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

#传不可变对象实例
def ChangeInt(a):
    print('修改前a的值：',a)
    a = 10
    print('修改后a的值:',a)
b = 2
ChangeInt(b)
print(b)

运行结果：
修改前a的值： 2
修改后a的值: 10
2

分析：
ChangeInt(b)把b的值复制给a，a未修改前a=b=同一内存地址；a=10重新修改后，a重新生成一个对象指针指向了10，但是b的指针还是指向的2，所以b的值为2而非10

#传可变对象实例
# 可写函数说明
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]]

五、参数

函数在调用的时候，可以传入参数，参数有实参和形参。

实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效

简单点说，形参就是函数接收的参数，而实参就是你实际传入的参数。

def print_str(str):  #str就是定义的形参
    '打印输出传入的字符串'
    print('要打印的字符串是：',str)
test = 'Hello world!'
print(test)  #test就是实参，当然这里也可以直接传入‘helloworld！’

函数的四种参数类型：

位置参数：

简单来说就是按照参数的位置来进行传参。位置参数是必传的，有几个位置参数在调用的时候就要传几个，否则就会报错；如果有多个位置参数，记不清楚哪个位置传哪个参数，可以使用位置参数的名字来指定调用。比如下面的fun函数也可以使用fun(y=1,x=2)这样来调用，这种调用方式叫做关键字传参

#位置参数
def fun(x,y):  #x,y就是位置参数
    print(x+y)
fun(3,3)  #调用这个函数
fun(y=2,x=6)

默认参数：

默认参数就是在定义形参的时候，给函数默认赋一个值，这样就算你在调用的时候没传入这个参数，它也是有值的。因此默认参数不是必填的，如果给默认参数传值的话，它就会使用你传入的值，如果不传入值，那么就使用默认的值。

注意：如果使用默认值参数的话，必须放在位置参数后面定义。

#有默认参数，不传值
def fun(x,y=6): 
    print(x+y)
fun(3)  #调用这个函数，y不传值
fun(y=0,x=6)  #抵用这个函数，y传值为0

运行结果：
9
6


#默认参数位置在位置参数前面
def fun(x=4,y):  
    print(x+y)
fun(y=3)  #调用这个函数

运行结果：
SyntaxError: non-default argument follows default argument

非固定参数：

位置参数和默认值参数都是参数个数固定的，如果一个函数，参数不固定，也不知道这个函数后期会扩展到何种程度，可能参数会越来越多，这个时候在用固定参数程序就不好扩展了。这个时候就应该使用非固定参数。非固定参数有两种，一种是可变参数，一种是关键字参数。

可变参数：

在变量名前边加入*号（变量名可以随便起，一般都叫args），其特点是：

1、不限制传参的个数
2、元素都放入一个元组中
3、不是必传的
4、它用在传参比较多的情况下

注意：如果位置参数、默认值参数、可变参数一起使用的的话，可变参数必须在位置参数和默认值参数后面。

#可变参数
def send_sms(*phone_num):
        print(phone_num)
send_sms()
send_sms(13199998888)
send_sms(13899992222,13499989234)

运行结果：
()
(13199998888,)
(13899992222, 13499989234)

def my(name,county='china',*args):   #可变参数、默认值参数、位置参数同时使用，可变参数必须在位置参数的后边，否则会报错
    print(name)
    print(county)
    print(args)
    print(kwargs)
my('gyb','beijing','天通苑',color = '红色',age = 19)

运行结果：
gyb
beijing
('天通苑', '海淀区')

关键字参数：

在变量前边加入两个*号（变量名可以随便起，一般都叫kwargs），其特点：

1、不限制传参的个数
2、不是必传的
3、元素都放在一个字典中
4、它用在传参比较多的情况下

注意：1、关键字也可以和位置参数、默认参数、可变参数一起使用，但是关键字参数必须在最后边，否则程序会出错；2、使用关键字参数的话，调用的时候必须使用关键字传参；

#关键字参数
def send_sms(**phone_num):
    print('详细信息：',phone_num)
send_sms()
send_sms(name='test',sex='20')
send_sms(addr = '北京市',country = '中国',c = 'abc',f = 'kkk')

运行结果：
详细信息： {}
详细信息： {'name': 'test', 'sex': '20'}
详细信息： {'addr': '北京市', 'c': 'abc', 'f': 'kkk', 'country': '中国'}


def my(name,county='china',*args,**kwargs):
    '''
    如果定义的函数如上边这样那么：
        1、先写位置参数，其次是默认值参数，然后是可变参数，最后是关键字参数，的顺序来写；
    '''
    print(name)
    print(county)
    print(args)
    print(kwargs)
# my('gaobo','japan','beijing','天通苑',color = '红色',age = 19)
my('gyb','beijing','天通苑',color = '红色',age = 19)

运行结果：
gyb
beijing
('天通苑',)
{'color': '红色', 'age': 19}

六、函数的返回值

每个函数都会有返回值，如果在函数中没有指定返回值的化，程序默认返回None。函数也可以返回多个值，如果返回多个值的话，会把返回的值都存放到一个元组中，返回的是一个元组。

函数之所以有返回值，是因为返回值需要供后边的程序调用。

Python中使用return语句来返回值，return有两个用处：1、函数遇到return就结束；2、返回函数的处理结果

#函数没有return语句，返回默认值None
def my():
    res = '这是一个测试函数！'
res1 = my()
print(res1)

运行结果：
None

#函数有return语句，返回函数值
def my():
    res = '这是一个测试函数！'
    return res
res1= my()
print(res1)

运行结果：
这是一个测试函数！

#函数有return，返回多个值
def my():
    res = '这是一个测试函数！'
    a = 123
    return res,a
res1= my()
print(res1)

运行结果：
('这是一个测试函数！', 123)

七、全局变量和局部变量

全局变量：定义在函数外部的变量拥有全局作用域，在整个程序中都生效。

局部变量：定义在函数内部的变量拥有一个局部作用于，出了这个函数就不生效了。

注意：全局变量如果要在函数中修改的话，需要加global关键字声明，如果是list、字典和集合的话，则不需要加global关键字，直接就可以修改。

total = 0  # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2  # total在这里是局部变量.
    print("函数内是局部变量 : ", total)
    return total
# 调用sum函数
sum(10, 20)
print("函数外是全局变量 : ", total)

运行结果：
函数内是局部变量 :  30
函数外是全局变量 :  0

#在函数中修改全局变量
total = 0  # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    global total   #声明变量total为全局变量
    total = arg1 + arg2  # total在这里是局部变量.
    print("函数内是全部变量 : ", total)
    return total
# 调用sum函数
sum(10, 20)
print("函数外是全局变量 : ", total)

运行结果：
函数内是全部变量 :  30
函数外是全局变量 :  30

#list的修改
total = [1,2,3,4,5]  # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    total.append(6)  #修改全局变量
    print("函数内是全部变量 : ", total)
    return total
# 调用sum函数
sum(10, 20)
print("函数外是全局变量 : ", total)

运行结果：
函数内是全部变量 :  [1, 2, 3, 4, 5, 6]
函数外是全局变量 :  [1, 2, 3, 4, 5, 6]

八、递归调用

递归函数，就是函数内部自己调用自己，这就叫递归。

递归调用，可以实现循环的效果，但是效率没有循环效率高；

def test():
    num = int(input('please input number:'))
    if num %2 != 0: #判断输入的数字是不是奇数
        return True  #如果是奇数的话，退出程序返回True
    print('不是奇数')
    return test() #如果不是奇数，继续调用自己，输入值
print(test())  #调用test函数

递归调用的特性：

1、必须有一个明确的结束条件

2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3、递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

九、匿名函数

Python使用lambda来创建匿名函数：

lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法：

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

实例：

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

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

运行结果：
相加后的值为 :  30
相加后的值为 :  40

lambda详细的参考连接：https://blog.csdn.net/zjuxsl/article/details/79437563