python ---------函数

一、为什么要使用函数？

　　因为如果没有函数我们平时的代码就会有很多重复

　　避免代码重用

　　提升代码的可读性

二、函数的定义与调用：

　　

1. def  函数名（参数1，参数2）

　　　　''' 函数注释'''

　　　　print（'函数体'）

　　　　return 返回值

函数就是封装一个功能

定义：

　　def 关键字开头，空格之后接函数名和圆括号，最后加一个冒号

　　def是固定的不能改变

函数名的定义和变量一样 ：数字字母下划线 任意组合 ，不能是数字开头  不能是关键字  要具有可描述性

函数的调用

返回值=函数名（参数1，参数2）#记得函数名后面加括号

下面我们先来定义一个求计算字符串长度的函数。假如我们的len()函数现在不能用了，那么我们就需要定义一个函数，求字符串的长度。如果让我们一次一次的去写相同的代码，会显得很麻烦。这时候我们的函数就上场了。

def length():
    s= 'hello world'
    length = 0
    for i in s :
        length +=1
    print(length)
print(length())    #因为没有返回值你打印最后会显示一个null
def length():
    s= 'bjbbabjsaofsa'
    num = 0
    for i in s:
        num +=1
    return num   
m = length()
print(m)
# print(length())#return的时候你可以定义一个变量来接收 也可以不接收直接打印 但是如果print就不可以 但是一般最好不要在函数中写print太lowle 

函数的返回值：

定义函数一般不要在函数中写print

return

1、在函数中遇到return就结束函数

2、将值返还给函数的调用者

　　无return

　　　　return None

　　return一个值该值是什么就返还什么

大家看一下对与函数中只能存在一个return 因为第一个碰到return就把函数结束了

>>> def func(a, b ,c):
    return a
    return b

>>> print(func(3, 7, 8))
3     #只返回第一个return的3  因为碰到第一个return就把函数结束了 其他的return 存在的没有意义了
>>> 

 

 

　　

函数的传递参数：

　　两个方面：

　　实参角度：

　　1形式参数和实际参数

　　

def my_len(a): #这个a就是形式参数 用来接收实际参数的
    return l
print(my_len(3))  #实际参数 实实在在存在的

 

　　2位置传参 一  一对应

　　

def func(a, b ,c):
    return a, b, c
print(func(2, 3,700))   #一一对应并且是当作一个元组打印出来

　　3、混合传参----->关键字永远在最后面

　　

def func(a, b=30 ,c): #形式参数和实际参数的一样都是直接赋值的要放在最后不然会报错，这个你看b直接赋值了但是放在了中间就报错
    return a, b, c，
print(func(2, 3,b=700))

 

　　

def func(a, c ,b=40):
    return a, b, c  #这个就是对的  就是全部都放在后面
print(func(2, 3,b=700))

如果你return的好几个值都在一起return那么最后的返回值显示出来就在一个元组内

 

3,函数名可以作为函数的参数。
def func():
pass
def func1(a):
a()
func1(func)
4,函数名可以作为函数的返回值。
def func1(a):
return a
func1(func)()

 

 

 

默认传参：

def Info(username,sex='男'):  #定义一个默认参数  sex
    with open('one',encoding= 'UTF-8',mode = 'a')as f :  #a就是追加内容
        f.write('{}\t{}\n'.format(username,sex))
while True :
    username= input('输入您的姓名：（男生为1开头）').strip()
    if '1' in username :
        username =username[1:]
        Info(username)
    else :
        Info(username,sex='女')

 函数的动态参数：

因为我们的静态参数只能接收固定的  不能接收哪些不确定的或者多余的变量

动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

按位置传值多余的参数都由args统一接收，保存成一个元组的形式       

按照关键字传值接收多个关键字参数由kwargs接收 保存成一个字典的形式

 

# def Func(a,*args,b='男'):
#     print(a)
#     print(b)
#     print(*args)
# Func(3,2,3,4,b='你')

# def n (a,b,c,**kwargs):
#     print(kwargs)
#
# n(1,2,3,d=5,f=6)
# def func(*args):
#     print(args) #(1,2,30,1,2,33.。。。。。)
# l1 = [1,2,30]
# l2= [1,2,33,21,45,66]
# func()
# def Func(*args):
#     print(args)
#
#
# li={'name':1,'age':5}
# l1 = [1,2,30]
# l2= [1,2,33,21,45,66]
# Func(*li)
# def Nu(a,b,*args,sex='麻痹'):
#     print(args)
#     print(sex)
# Nu(3,6,'pfapifuafjfbsa',sex='弄哈')
# def N():
#     print(a,*args,**kwargs)
#     print(args)
#     # print(kwargs)
#     print(kwargs)
#
#
# N(1,'2345',b=12)
#*agrs  动态参数  万能参数

#args 动态参数 接收的就是实参对应的 所有位置参数 并将其放在元组中
#位置参数  *args 默认参数
# def func (a,b,c,*args,e='男'):
#     print(a)
#     print(b)
#     print(c)
#     print(args)
#     print(e)
# func(1,2,3,4,5,6,e='女')
#**kwargs
# def func(a, b,c, d, *args, e='男',**kwargs):
#     print(a)
#     print(b)
#     print(c)
#     print(d)
#     print(args)
#     print(kwargs)
# func(1,2,3,4,5,m=9)

# 最终顺序：位置参数，*args 默认参数 **kwargs
# def func(a,b,c,e='laowang',*args):
#     print(a)
#     print(b)
#     print(c)
#     print(e)
#     print(args)
# func(1,2,3,4,7,8,89)  #如果默认参数放在args之前那么传值就会把args给传递给默认参数一个 把它给覆盖了 所以一般不这样做

# *的魔法运用
# def func(*args):
#     print(args)
#
# # l =[1,2,3]
# # l2=[1,2,3,4,5,6]
# l=(1,2,3,4)
# l2=(2,3,4,5)
# func(*l,*l2)  #*号可以把两个列表元组给传递进函数内 然后转化位一个元组中 因为*args接收完 那么用args输出后就会把所有的元素都放在元组中

# def func(*args):
#     print(args)
#
# l = [1,23,4,56,78]
# l1=[1,2,3,4]
# a={'name':'alex','age':12}
# func(*a)  #如果是字典运用*号然后再把字典让args接收的话就会把字典中的key值给放在元组中打印出来
# func(*l,*l1) # *星号可以放列表  字符串  元组 字典（字典只是显示key值），int类型是不可以放进去的
# def func(**kwargs):
#     print(kwargs)
# dic ={'name1':'alex','age1':47}
# dic1={'name':'old_man','age':56}
# func(**dic,**dic1)

#单个的*可以接收不同的列表、元组、字符串内的相同的元素 因为它可以把相同的元素 变成同一个，而**两个星号不可以接收两个人不同的字典内的相同的key就是用**组合两个字典 这两个字典内不可以出现相同的key

#在函数的定义时， *rags、**kwargs# 代表的是聚合
# def func(*args,**kwargs):
#     print(args)
#     print(kwargs)
# dic1 = {'name1':'alex','age1':46}
# dic2 = {'name':'老男孩','age':56}
# func(*[1,2,3,4],*'jkbabl',**dic1,**dic2)   *和 **可以同时使用的
#

# def func(*args,**kwargs):
#     print(args)
#     print(kwargs)
#
# dic1 = {'name1':'alex','age1':46}
# dic2 = {'name':'老男孩','age':56}
# func(*[1,2,3,4],*'bjbfbabfa',**dic1,**dic2) #字符串如果打散放入args中就会以单独的字符串类型的形式放入进去

 

*args必须放在默认参数之前放在位置参数之后 ，**kwargs必须放在最后 也就和静态参数一样 默认参数都在最后 而**kwargs接收的是赋值的默认参数 所以必须放在最后