Python3函数

#!usr/bin/python
#coding=UTF-8
'''
Python3函数
'''
'''
1、函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
2、函数能提高应用的模块性，和代码的重复利用率。
'''

'''
定义一个函数：
    1、函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
    2、在圆括号中定义参数
    3、函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
    4、函数内容以冒号 : 起始，并且缩进。
    5、return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。
'''
#无返回函数
def hello():
    print('Hello Python')
hello() #输出 Hello Python

#求面积 有返回值函数
def area(width, height):
    return width * height

print(area(5,2))    #输出 10

'''
函数中的参数
    不可变类型：如整数、字符串、元组。
               如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。
               如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
    可变类型：  如 列表，字典。
               如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
'''

#函数传递不可变对象
def nochange(a):
    print(id(a))    #输出 2918915074352
    a = 10
    print(id(a))    #输出 2918915074640

a = 1
print(id(a))    #输出 2918915074352
nochange(a)

#输出
#   2918915074352
#   2918915074352
#   2918915074640

#传递参数是不可变对象（例如：int、float、字符串、元组、布尔值等），
# 实际传递的还是对象的引用，进行“赋值操作”时，由于不可变对象无法修改，系统会创建一个新的对象。

#函数传递可变参数
def change(list1):
    print(id(list1),list1)  #输出 3004396518400 [1, 2, 3]
    list1.append(55)
    print(id(list1),list1)  #输出 3004396518400 [1, 2, 3, 55]

list1 = [1,2,3]
print(id(list1),list1)  #输出 3004396518400 [1, 2, 3]
change(list1)
print(id(list1),list1)  #输出 3004396518400 [1, 2, 3, 55]

#传递参数是可变对象（如：字典、列表、自定义的其他可变对象等），
# 实际传递的还是对象的引用。在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象。

'''
必需参数
    必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数
    关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
    使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
默认参数
    调用函数时，如果没有传递参数，则会使用默认参数。
不定长参数
    需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。
    def functionname([formal_args,] *var_args_tuple ):
        "函数_文档字符串"
        function_suite
        return [expression]
    加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
    
    加了两个星号 ** 的参数会以字典的形式导入，语法如下：
        def functionname([formal_args,] **var_args_dict ):
           "函数_文档字符串"
           function_suite
           return [expression]
    
'''
#必需参数函数
def needstr(str):
    print(str)
#needstr()   #输出 TypeError: needstr() missing 1 required positional argument: 'str'
needstr('Hello Python') #输出 Hello Python

#关键字参数函数
def user(name,age):
    print('名字：',name,'年龄：',age)
user(age = 10,name = '陈丽')  #输出 名字： 陈丽 年龄： 10

#默认参数
def user1(name,age = 20):
    print('名字：',name,'年龄：',age)
user1(name = '陈丽')  #输出 名字： 陈丽 年龄： 20
user1(name = '陈丽',age = 50)  #输出 名字： 陈丽 年龄： 50

#不定长参数
#一个星号 * 参数
def user2(name, *score):
    print('名字：',name,'分数：',score)
user2('陈丽', 100, 90 , 99)  #输出 名字： 陈丽 分数： (100, 90, 99)
user2('陈丽') #输出 名字： 陈丽 分数： ()

#两个星号 ** 参数
def printscore(name, **score):
    print('名字：',name)
    print(score)
printscore('陈丽', c=90, e=100, m=99)

#输出
#名字： 陈丽
#{'c': 90, 'e': 100, 'm': 99}

#声明函数时，参数中星号 * 可以单独出现
# 如果单独出现星号 * 后的参数必须用关键字传入。
def f(a,b,*,c):
    return a+b+c
#f(1,2,3)    #输出 TypeError: f() takes 2 positional arguments but 3 were given
f(1,2,c=3)   #输出 6

'''
匿名函数
    1、python 使用 lambda 来创建匿名函数。
    2、lambda 只是一个表达式，函数体比 def 简单很多。
    3、lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
    4、lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
    匿名函数语法：
        lambda [arg1 [,arg2,.....argn]]:expression
'''

sum = lambda a,b : a+b
print ("相加后的值为 : ", sum( 10, 20 ))  #输出 相加后的值为 :  30

'''
return语句
    return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。
    不带参数值的return语句返回None。
'''
def sum(a,b):
    return a+b
total = sum(10,20)
print(total)    #输出 30

'''
强制位置参数
    一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
'''
def pr(a,b,/,c,d,*,e,f):
    print(a,b,c,d,e,f)
pr(1,2,3,4,e=5,f=6) #输出 1 2 3 4 5 6
#pr(1,2,3,4,5,f=6)   #输出 TypeError: pr() takes 4 positional arguments but 5 positional arguments (and 1 keyword-only argument) were given
pr(1,2,d=3,c=4,e=5,f=6) #输出 1 2 4 3 5 6
#形参 a 和 b 必须使用指定位置参数，
#形参 c 或 d 可以是位置形参或关键字形参
# 而 e 或 f 要求为关键字形参