DAY9 函数初识(各种参数的用法)

函数初始

为什么需要函数？

　 1.合并重复，减少代码的重复率。

　　2.测试方便

　　3.修改方便

　　4.打包

　　5.映射

函数的最主要目的：封装一个功能。

 

函数的定义:

 

def 函数名（argv):
    函数体

 

　　 def  ： 定义函数的关键字。

　  函数名：自定义函数名，一般都为小写字母，与变量名一样最好具有良好的描述性。

　　argv  :  参数，可以有多个，用","逗号分隔

　　statement ： 函数体，具体的代码

　　return ：函数的返回值，默认不写的话返回的是None；可以没有返回值，可以返回一个值，可以返回多个值。

 

创建函数，调用函数：

 

def mylen():
    """
    创建了一个名为mylen的函数
    计算s1的长度
    """
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

mylen()    #执行函数，函数名（）表示执行函数。

 

 

函数的返回值：return

　　作用：

　　1.函数一旦遇到return，就会结束。

　 　2.给函数的执行者返回值，方便后续使用

　　类型：

　　1.没有返回值，默认返回的是None。

　　2.返回一个值。

　　3.返回多个值，以元组的形式返回。

'''没有返回值，默认返回的是None'''
def mylen():
    s1 = 'hello,world'
    length = 0
    for i in s1:
        length = length +1
    print(length)

str_len = mylen()  #因为没有设置返回值，所以默认返回None
print(str_len)
>>>None


'''返回一个值'''
def mylen():
    s1 = 'hello,world'
    length = 0
    for i in s1:
        length = length + 1
    return  length

str_len = mylen()
print(str_len)

'''返回多个值：可以返回多个，任意数据类型的值'''
def demo1():
    return 1,2,3,4

def demo2():
    return 1,['a','b'],3,4

res1 = demo1()
res2 = demo2()
print(res1)
print(type(res1))   # 元组

print(res2)
print(type(res2))   #元组

　　

函数的参数：形参与实参

　　形参：函数完成其工作所需要的一项信息，只是一个形式，用于接受实参。

　　实参：调用函数时，实际传递给函数的信息。

'''站在实参的角度来看'''

　　1.位置参数

#位置参数：调用函数时，python必须将函数调用中的实参与每一个形参关联，为此最简单的关联就是按照位置关联。因此，位置参数中，形参与实参的个数必须一样，位置一一对应。

def describe_pet(animal_type,pet_name):
    print('I have a '+ animal_type + '.')
    print('My '+ animal_type +"'s name is " + pet_name.title())
describe_pet('dog','herry')
>>>
I have a dog.
My dog's name is Herry

#如果改变参数的位置
describe_pet('dog','herry')
>>>
I have a herry.                    #animal_type这个形参接受的就是‘herry’了.
My herry's name is Dog

　　2.关键字参数

# 关键字参数：用在函数调用的时候，通过关键字传值，可以不需要一一对应位置顺序。

def  mymax(x,y):
    the_max = x if x>y else y
    return the_max
max_num = mymax(y=10,x=20)    #位置不用一一对应了。
print(max_num)

　　3.混合型参数（位置参数+关键字参数）

# 位置参数与关键字参数混合调用，但是关键字参数必须在位置参数之后。

def mymax(x,y):
    the_max = x if x>y else y
    return the_max

max_num = mymax(10,y=20)      #关键字参数必须在位置参数之后
print(max_num)

　

 

'''站在形参的角度来看'''

　　1.位置参数，与上面的是一样的。

　　2.默认参数

'''
默认参数：把变化比较小的参数可以设置成一个默认值，在传参时可以忽略不传，如果不传就使用默认值；如果传，就会覆盖掉默认值。

默认参数使用场景：“参数的值不经常改变，但是一直在用”

谨记：默认参数的陷进！！！默认参数不要设置为可变数据类型。
'''

#默认参数
def stu_info(name,sex='male'):
    print(name,sex)

stu_info('alex')    #sex可以忽略不传
>>>
alex,male

stu_info('eva_j','female') #sex的默认值会被覆盖
>>>
alex,female


#默认参数的陷进：默认参数不要为可变数据类型。
def default_para(a,l=[]):
    l.append(a)
    print(l)
default_para('alex'）
# >>>['alex']
default_para('egon')
# >>>['alex', 'egon']

！！！通过查看id，发现两次调用函数列表的内存地址都是一样的，说明列表都是同一个列表！！！

#像列表这种可变类型的改进方法:

def default_para(a,L=None):
    if L is None:
        L = []
    L.append(a)
    return L

print(default_para('alex'))
>>>['alex']
print(default_para('egon'))
>>>['egon']

　3.任意参数，动态参数：在函数定义的时候，在上*代表的是聚合。

　　一. *args：接受位置传值，把所有位置参数都由*args接受，聚合保存为一个元组。

#一。观察*args的表现形式
def foo(*args):
    return args,type(args)

print(foo(1,2,3,4,5))
>>>((1, 2, 3, 4, 5), <class 'tuple'>)     #所以可以观察到，*args会把接受到的位置参数组成一个元组。


#二。既然*args是一个元组的形式，那么就可以对它进行遍历。
def mysum(*args):
    the_sum = 0
    for i in args:
        the_sum = the_sum + i
    return the_sum

res = mysum(1,2,3,4)
print(res)

#三。观察位置参数，与*args接受参数
def foo2(a,b,c,*args):
    print(a)
    print(b)
    print(c)
    print(args)

foo2(1,2,3,4,5,6,7,8)
>>>
1      #根据位置参数，形参与实参一一对应，a接受了1
2      #根据位置参数，形参与实参一一对应，b接受了2
3      #根据位置参数，形参与实参一一对应，c接受了3
(4, 5, 6, 7, 8)    #*args接受了剩下的所有位置参数；*args就相当于一个大胃王，把剩余的位置参数都吃掉。

#四。如果没有给*args传值，它会报错吗？？？
def foo3(a,b,c,*args):
    print(a)
    print(b)
    print(c)
    print(args)  

foo3(1,2,3)    #根据形参与实参一一对应，a接受了1，b接受了2，c接受了3，*args没有参数，会如何？
>>>
1       
2       
3
()              #根据结果我们可以知道，就算没有给*args传值，它会形成一个（）空元祖。

'''
从上面的代码，我们可以知道。*args就是一个胃口极大的家伙，会把多个位置参数都接受。
所以位置参数必须放置在*args的前面。
'''

　　1.1 位置参数，默认参数，*args的顺序

#前提：从上面的代码，我们已经知道：
#1.位置参数需要放在默认参数的前面。
#2.位置参数需要放在*args的前面。
#那么，默认参数和*args的排序位置又是怎么样的呢？我们接下来就来分析~

#一。默认参数在*args的前面
def foo4(a,b,c,d='alex',*args):
    print(a)
    print(b)
    print(c)
    print(d)
    print(args)
foo4('he','bob','taibai','wusir','evj')
>>>
he           #a接受'he'
bob         #b接受'bob'
taibai      #c接受'taibai'
wusir       #d原本是默认参数,这里接受到了新的值,所以原值被覆盖了
('evj',)    #*args接受剩下的位置参数


##从上面看出，默认参数如果在*args的前面，原值就会被覆盖掉，所以默认参数需要放置到*args的后面##

　　参数顺序： ‘位置参数  *args  默认参数’

  1.2 *args的拓展以及魔法方法

# 如果有现成的列表，可以通过“*列表名”把列表传入

#一。如果传入不加“*”
l1 = [1,2,3]
l2 = ['he','alex','wusir']
def func(*args):
    print(args)
func(l1,l2)      
>>> 
([1, 2, 3], ['he', 'alex', 'wusir'])           #会把每个列表当成一个独立的元组的元素

#魔法方法：打散
l1 = [1,2,3]
l2 = ['he','alex','wusir']
def func(*args):
    print(args)
func(*l1,*l2)
>>>
(1, 2, 3, 'he', 'alex', 'wusir')                #会把列表的元素打散，然后组成一个元组。

　　二. **kwargs：keyword args，顾名思义关键词动态参数，与字典对应。

# 一。**kwargs接受关键字参数，观察其表现形式

def func(**kwargs):
    print(kwargs,type(kwargs))

func(name='he',age=23,sex='male')
>>>
{'name': 'he', 'age': 23, 'sex': 'male'} <class 'dict'>   #**kwargs接受多个关键词参数，将他们组织成一个字典的形式。

#二。所以**kwargs符合字典的所有特性。
def car(**kwargs):
    for k,v in kwargs.items():
        print(f'{k}:{v}')
car(color='red',price=20,user='he')
>>>
color:red
price:20
user:he

#三。从上面我们已经理清楚了位置参数，默认参数，*args的顺序的问题。现在，加入**kwargs会如何？
###系统规定了**kwargs放在所有参数的最后面。####
def func(a,b,*args,sex='male',**kwargs):
    print(a)
    print(b)
    print(args)
    print(sex)
    print(kwargs)
func(1,2,3,4,5,6,name='he',age=23,sex='female')

#所以，参数的位置为：位置参数，*args，默认参数，**kwargs

　　参数顺序： ‘位置参数  *args  默认参数   **kwargs’ 

　2.1 **kwargs的拓展以及魔法方法

#如果现在有现成的列表，可以通过**dict把字典传入

dic = {'color':'red','price':100}
def car(**kwargs):
    print(kwargs)
car(**dic)
>>>
{'color': 'red', 'price': 100}


# 魔术方法：打散
def func(**kwargs):
    print(kwargs)

dic = {'name1':'he','age1':23}
dic1 = {'name2':'alex','age2':33}
func(**dic,**dic1)
>>>
{'name1': 'he', 'age1': 23, 'name2': 'alex', 'age2': 33}

　　三. 结合*args,**kwargs的函数，称为万能参数。

# *args接受所有的位置参数，**kwargs接受所哟关键字参数。
def func(*args,**kwargs)；
    pass