函数变量，参数

今日学习总结：

一、参数：

形参即在定义函数时，括号内声明的参数。形参本质就是一个变量名，用来接收外部传来的值。

实参即在调用函数时，括号内传入的值，值可以是常量、变量、表达式或三者的组合:

1.不定长参数   *args 或者  **kwargs

*  一个星星 表示可变长度的位置参数

def index(a, b, c, *args):
    print(a, b, c, *args)     # 加* 表示把溢出的数据打撒后输出
index(1,2,3,4,5,6)


结果：1 2 3 4 5 6

def index(a, b, c, *args):
    print(a, b, c, args)      # 不加* 表示把溢出的数据以元组的形式输出
index(1,2,3,4,5,6)

结果：1 2 3 (4, 5, 6)

 

**  两个星星 表示可变长度的关键字参数

def index(a, b, c, **kwargs):
    print(a, b, c, *kwargs)     # 加* 表示把溢出的数据取出它的键输出
index(1,2,3,d=4,e=5,f=6)

结果： 1 2 3 d e f

def index(a, b, c, **kwargs):   # 在这里 ** 表示接受溢出的关键字参数。kwargs表示的是一个字典{'d':4,'e':5,'f':6}
    print(a, b, c, kwargs)      # 不加* 表示把溢出的数据以字典的方式后输出
index(1,2,3,d=4,e=5,f=6)

结果：  1 2 3 {'d': 4, 'e': 5, 'f': 6}

* 的另外一个知识：表示打撒

def index(a,b,c,f):
    print(a,b,c,f)
index(1,2,3,[6,7,8])             #传入的实参可以为列表

结果：1 2 3 [6, 7, 8]

def index(a,b,c,f,g,h):         #如果这里不写g,h形参是错的 因为7，8打散后没有地方存
    print(a,b,c,f)
index(1,2,3,*[6,7,8])
 
结果：1 2 3 6          

def index(a,b,c,f,g,h):
    print(a,b,c,f,g,h)
index(1,2,3,*[6,7,8])

结果：1 2 3 6 7 8

2.默认参数

def reg(name,age,gender='male'):                        # 在这里gender被附了值，是默认参数
    print(f'用户名:{age},年龄:{age},性别:{gender}')        # {}必须写参数，写形参中的任意一个
reg('tank',18)

 结果：用户名:18,年龄:18,性别:male

def reg(name,age,gender='male'):                                 # 在这里gender被附了值，是默认参数

print(f'用户名:{name},年龄:{age},性别:{gender}')                    # {}必须写参数，写形参中的任意一个

reg('tank',18)
reg('小红',20, 'female')                                           #虽然gender被附了值，是默认参数，但是仍然可以给gender传参

结果：
用户名:tank,年龄:18,性别:male
用户名:小红,年龄:20,性别:female

案例一：

 

注意：定义的形参，不一定非要在print()里用，其他语句里也可以用。

def reg(name,age,hobby,l1=[]):                                # l1是被[]赋值了，是默认参数
    l1.append(hobby)
    print(f'用户名:{name},年龄:{age},爱好:{l1}')
reg('tank',18,'game')
reg('小红',30,'shopping')

结果：
用户名:tank,年龄:18,爱好:['game']                               #不同人的爱好 用了同一个列表。
用户名:小红,年龄:30,爱好:['game', 'shopping']

改进方法一：让不同的人爱好各自用各自的列表

def reg(name,age,hobby,l1=[]):                  #[]是可变类型，定义形参时最好不要用可变类型
    l1.append(hobby)
    print(f'用户名:{name},年龄:{age},爱好:{l1}')
reg('tank',18,'game',[])                        #这里的[]表示给默认参数l1赋了[]
reg('小红',30,'shopping',[])                     #这里的[]表示给默认参数l1赋了[]

结果：
用户名:tank,年龄:18,爱好:['game']
用户名:小红,年龄:30,爱好:['shopping']

改进方法二：让不同的人爱好各自用各自的列表

 

def reg(name,age,hobby,l1=None):                                  # l1=None 说明l1是布尔值 False .l1是默认参数
    if not l1:  或 if l1==None                                                  # not l1  说明布尔值是 True
        l1=[]
        l1.append(hobby)
    print(f'用户名:{name},年龄:{age},爱好:{l1}')                    ##注意：这个代码的实现原理：每执行reg语句，都会 执行if语句，然后给l1重新赋个列表[]
reg('tank',18,'game')
reg('小红',28,'shopping,cooking')


结果：
用户名:tank,年龄:18,爱好:['game']
用户名:小红,年龄:28,爱好:['shopping,cooking'

3.位置参数

位置即顺序，位置参数指的是按顺序定义的参数

4.关键字参数

在调用函数时，实参可以是key=value的形式，称为关键字参数

二、返回值：

1.不写return ：默认返回None

注意：没有写return 默认返回的是None 

def index():
     print('hello world')                          
 index()

结果：hello world

 def index():
     print('hello world')
 print(index())

结果：
hello world
None


 def index():
     print('hello world')
 print(index())
 index()

结果：                # 因为在print(index())时，已经调用函数了，后面在再写一个index(),表明又调用了一次函数，这是一个嵌套
hello world
None
hello world

def index():
    print('hello world')
index()                        # 在这里是第一次调用函数  
print(index())                 # 这里是第二次调用函数

结果：

hello world
hello world
None

2.只写return：只有结束函数体代码的效果，返回None

s1='hello world'
def s1_len():
    count = 0
    while True:
        for i in s1:
            if i == 'r':
                print(count)
                return              
            count += 1
print(s1_len())

结果：

8
None

3.写return None ：与只写return的效果相同

s1='hello world'
def s1_len():
    count = 0
    while True:
        for i in s1:
            if i == 'r':
                print(count)
                return  None          
            count += 1
print(s1_len())

结果：
8
None

4.return返回一个值: 可以将返回的结果，当做一个变量值来使用

def home(a,b):
    if a > b:
        return a
    else:
        return b
res = home(7,2)   # 函数也是一个变量，所有可以赋值给res
print(res)

结果：7

5.return返回多个值:
01、将返回的多个值，默认存入元组返回
02、函数的返回值不想被修改
03、可以自己指定返回的数据类型

return:它是一个函数结束的标志，函数体代码只要执行到return，函数执行结束

01 和 02

a = 1
b = 2
c = '3'
d = [4, 5]
e = {'name': 'sean'}
def func(a, b, c, d, e):
    return a, b, c, d, e
print(func(a, b, c, d, e))

结果：
1, 2, '3', [4, 5], {'name': 'sean'})    # 是元组形式



def fun():
    return 1,'2',['a','b'],{'sean':18}
print(fun())

结果：
(1, '2', ['a', 'b'], {'sean': 18})

03

def fun():
    return {'sean':18}    #指定类型为字典
print(fun()

结果：

{'sean':18}

def fun():
    return {'sean',18}   # 指定类型为字典
print(fun())

结果：

{'sean',18}

def fun(): 
    return 4 # 指定类型为数字
print(fun()) 

结果：
4

def fun(): 
    return (4,5,6) # 指定类型为元组 
print(fun())

结果：
（4,5，6）

 三、调用函数的三种方式：

 1.语句形式：

foo()

2.表达式形式：

x=my_min(1,2)

y=10*my_min(1,2)

3.函数作为参数的形式，也是函数的嵌套：

def max(x,y):

    if x>y:

         return x

    else:

         return y

res = max(1,max(2,3))

print(res)