Python基础语法（python函数）python函数的各种使用方法

python函数
函数时执行特定任务和完成特定功能的一段代码，如print、input等函数
函数的作用：
1、复用代码
2、隐藏实现细节
3、提高可维护性
4、提高可读性便于调试

函数的创建：
def 函数名（输入参数）:
    函数体
    return xxx

return语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

函数的参数传递：
函数调用的参数传递
位置实参：
根据形参对应的位置进行实参传递
关键字实参：
根据新参名称进行实参传递

#函数的创建
def hua(a,b):    #a和b是形参，形参的位置是在函数的定义处，形参就是在函数中起占位作用
    c=a-b
    return c   #结束后把c返回到函数调用处

#函数的调用，位置传参
zhi=hua(10,20)   #10和20是实参，在这里属于实际参数值，简称实参，实参的位置是函数的调用处
print(zhi)


#关键字传参
wei=hua(b=10,a=20)
print(wei)

在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值    arg1的修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值    arg2的修改,append（10），会影响到n2的值

#例
def fun(arg1,arg2):
    print("arg1=",arg1)
    print("arg2=",arg2)
    arg1=100
    arg2.append(10)
    print("arg1=",arg1)
    print("arg2=",arg2)

n1=11
n2=[22,33,44]
print(n1)
print(n2)
print("---------------------")
fun(n1,n2)  #位置传参，arg1，arg2，是函数定义出的形参。n1，n2是函数调用处的形参。总结。实参名称与形参名称可以不一致

print(n1)  #返回值是11，因为n1是不可变参数，即使函数体内被修改成100，函数结束后，n1依然是11，不可变参数的值不会被改变
print(n2)  #返回值是[22, 33, 44, 10]，n2为可变参数，函数可以改变n2的值



#函数的妙用
def hua6(name,age,xingbie="女"):   #函数可以设置默认参数，调用时没有传递参数就会使用默认参数
    print("名字：",name)
    print("年龄：",age)
    print("性别",xingbie)

hua6(name="成龙",age=20,xingbie="男")   #调用时设置了参数，默认参数就会被修改为调用时设置的参数
hua6(name="李小龙",age=20,xingbie="男")
hua6(name="蔡徐坤",age=20,)    #调用时没有传递性别参数，所以使用性别的默认参数女。

"""
输出结果
名字： 成龙
年龄： 20
性别 男
名字： 李小龙
年龄： 20
性别 男
名字： 蔡徐坤
年龄： 20
性别 女
"""

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

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]
   
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

#在不知道命名多少个形参时，可以在一个形参名前面加一个*号，就会把这个形参设置成不定长形参。存放所有未命名的变量参数，但会以元组形式导入
def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    print(vartuple)


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

#定义一个可变的位置参数
def shu(*Hua):  #在不知道给函数命名多少个形参时，可以在定义形参名前面加一个*号，这样的形参就是不定长的形参，可以放入多个参数，返回值是元组形式
    print(Hua)  #输出传入的参数

shu(10)  #返回值(10,)，不定长的形参返回值是元组形式
shu(10,20)  #返回值(10, 20)
shu(10,20,30,90)  #返回值(10, 20, 30, 90)
#如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：
def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    for var in vartuple:
        print(var)
    return


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

还有一种就是参数带两个星号 **基本语法如下：
def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

#加了两个星号 ** 的参数会以字典的形式导入。
def printinfo(arg1, **vardict):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    print(vardict)


# 调用printinfo 函数
printinfo(1, a=2, b=3)



"""
函数的返回值  return
函数在定义时，是否需要返回值，视情况而定
1、如果函数没有返回值（函数执行完毕后不需要给调用处提供数据的函数就没有返回值）  return可以省略不写
2、函数的返回值，如果是1个，直接返回原值类型（原来的需要返回的值是什么类型，就返回什么类型的值）
3、函数的返回值，如果是多个，返回的结果为元组
"""

#例，如果函数需要返回多个值
def fun(num):
    old=[]   #存储奇数的空列表
    even=[]  #存储偶数的空列表
    for i in num:  #用i依次遍历实参
        if i%2:   #如果i%2的值的bool值是True的话，则在奇数列表加入这个数，除0外的整数的bool值为True。
            old.append(i)  #在列表中加入i这个实参
        else:  #因为0的bool值是False，而只有偶数余2会等于0，所以偶数存放在even这个列表里
            even.append(i)
    return old,even
    #将old，even的值返回给调用处，因为返回多个值，所以返回的值会以元组的方式返回，old和even的值会以逗号分割，（old，even），因为在这里old和even是列表，所以返回值的形式是（[old],[even]）

#调用制定好的fun函数
lst=[10,29,34,23,44,53,55]  #定义一个整数列表
print(fun(lst))   #将lst这个整数列表放入fun函数的形参里成为实参，然后输出这个函数的结果
#返回值是  ([29, 23, 53, 55], [10, 34, 44])  函数里的old和even的值以元组的形式输出





#无返回值的函数
def fun3():
    print("hello")  #调用该函数时，输出hello

fun3()  #调用函数，结果返回值是hello



#只返回一个值的函数
def fun2():
    return "hello"   #把hello这个字符串返回给调用处

res=fun2()  #调用函数，把函数的返回值赋值给res这个变量
print(res)  #输出这个变量



#多个返回值的函数
def fun1():
    return "hello","python"  #返回hello和python两个值

print(fun1())   #返回值是('hello', 'python')，函数返回多个值时，返回的值会以元组形式返回，每个值的内容以逗号隔开

函数的参数定义
函数定义默认值参数
函数定义时，给形参设置默认值，之后又与默认值不符的时候才需要传递实参

def han(a,b=10):   #给形参b设定一个默认值10，在没给b传递实参时就采用这个默认值
    print(a,b)    #调用函数后，输出a和b的值

han(100)  #返回值是100,10. 因为只给a传递了实参，所以b采用形参的默认值
han(10,30)  #返回值是10,30. 因为给b传递了实参，所以调用时传递的实参替换了形参的默认值