python函数基础（下）

函数基础（下）

1.1 函数参数

1.1.1 * args

定义函数时，可以再形参的前面加一个 * 号，我们的形参就能获得我们所有实参。这个 * 代表所有的意思 他会将我们所有的实参保存到一个元组当中

def fn(*a):
    print(a)
    print(type(a))
fn(1,2,3,4,5)

(1, 2, 3, 4, 5)
<class 'tuple'>

*a能接受所有的实参，并且将实参保存到一个元祖中
装包，我们把这些散开的数据，转到一个元祖中，这就叫装包
好处就是相传几个就是几个，不传也可以

def sum(*a):
    result = 0 #初始化
    for i in a:
        result += i  #result = result + i
    print(result)
sum(1,2,3,4,5,6,7,8,9)

45

#带*号的形参只有一个，因为你写多了就没法分值
#带*号的参数可以和其他参数配合使用，但是得写在最后面

def fn(a,b,*c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
fn(1,2,3,4,5,6,7,8,9,10)

def fn(*a,b,c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
fn(1,2,3,4,5,6,7,8,b=9,c=10)

a= 1
b= 2
c= (3, 4, 5, 6, 7, 8, 9, 10)

a= (1, 2, 3, 4, 5, 6, 7, 8)
b= 9
c= 10

使用带 * 号的参数一般取名为args

*args弊端就是只能接受位置参数

1.1.2 * * kwargs

def fn(**args):
    print('args=',args)
    print(type(args))
fn(a=1,b=2,c=3)

args= {'a': 1, 'b': 2, 'c': 3}
<class 'dict'>

总结：
**形参可以接收任意的关键字参数，会将这些参数统一保存到字典当中，字典的键就是参数的名字，字典的值就是参数的值，所以现在这个键a值是1，b值是2，c值是3
注意：**形参也是只能有一个，并且必须写在所有参数最后，他必须得是最后一个，他的命名潜规则是kwargs

1.1.3 同时使用不定长参数

**当要同时使用 * args和 * *kwargs的时候， * args是必须写在 * *kwargs的前面，这是规定

def fn(a,b,*args,**kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)
fn(1,2,3,4,5,6,1,6,3,k=1,ww=3,c=5)

1
2
(3, 4, 5, 6, 1, 6, 3)
{'k': 1, 'ww': 3, 'c': 5}

1.1.4 参数的解包

def fn(a,b,c,d,e,f):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
    print('e=', e)
    print('f=', f)
t = (1,2,3,4,5,6)
# fn(t[0],t[1],t[2])
fn(*t)

a= 1
b= 2
c= 3
d= 4
e= 5
f= 6

传递实参时，也可以在序列类型的参数前面添加 * 号，这样会自动将序列中的元素依次作为参数传递
注意:序列中的元素的个数必须和我们函数形参的个数一致
    
    def fn(a,b,c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
# fn(*[1,2,3]) # 列表也行
fn(*[1,2,3,4]) # 报错， 序列元素和形参必须一致

a= 1
b= 2
c= 3

def fn(a,b,c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    
d = {'a':10, 'b':20, 'c':30}
fn(**d)

总结：
1.*args适用于接收多个未命名的位置参数，**kwargs用于接收关键字参数，其中args是一个元组类型，而kwargs是一个字典类型的数据
2.*args也就是把元组中的数据拆分成单个的数据
**kwargs吧字典中的数据拆分成单个的键值对

1.2 函数的返回值

返回值就是函数执行以后返回的结果

f(x) = 2x+1

x=1 ==>3 f(1)=3

x=2 ==>5 f(2)=5

def fn():
    return [1,2,3,4]
# 获取返回值我们的方式是  把函数调用当做一个值来输出
x = fn()
print(x)
print(fn())

return后面是什么， 返回的结果就是什么
return后面可以是任意的值，包括函数，跟什么就返回什么
无论定义的是返回什么类型，return只能返回单个值，但是值可以有多个元素

def fn1():
    return [1,3,5]
print(fn1())
print(type(fn1()))

def fn2():
    return ('1,3,5')
print(fn2())
print(type(fn2()))

(1, 3, 5)
<class 'tuple'>
[1, 3, 5]
<class 'list'>
1,3,5
<class 'str'>

def fn():
    def fn2():
        print('hello')
    return fn2
r = fn()
print(r)
r()

<function fn.<locals>.fn2 at 0x00000175C0F389D0>
hello

None是python一个特别空值，用来代表空的

def fn():
    pass
print(fn())  # None ==> 空值，不可以理解为0
print(type(None))

None
<class 'NoneType'>
如果不给一个函数返回值，那么他的返回值就是空的None
只要函数不带return，那么返回的是None

def fn():
    return
print(fn())

总结：如果仅仅写一个return或者不写return，就等价于return None
None是python一个特别空值，用来代表空的

def fn():
    print('抄一遍')
    print('抄两遍')
    print('抄三遍')
    return
    print('抄四遍')
fn()

抄一遍
抄两遍
抄三遍

在函数中，return代表函数执行结束

def fn():
    for i in range(1,101):
        if i == 66:
            print('老师心痛了，提前结束')
            #break
            return
        print(f'抄{i}遍')
fn()
break:退出当前循环
continue；跳过本次循环，但是对于后面没有影响
return：用来结束函数

def sum(*args):
    result = 0
    for i in args:
        result += i
    return result
r = sum(1,2,3,4)
print(r+10)

print(print())

a = len('hello')
print(a)

fn()和fn的区别：
fn==》函数对象，打印它其实就是在打印函数对象
fn（）==》调用函数，打印fn（）其实就是在打印fn（）的返回值

总结；
return语句的作用
结束函数调用，返回值
函数体中return语句有指定的返回值 时  返回的是  其值
函数体中没有return语句，函数运行结束会隐含返回一个None作为返回值，类型是Nonetype，与return，returnNone等效，都是返回None

print和return
print仅仅是打印在控制台上，而return则是将return后面的部分作为返回值，作为函数的输出，可以用来变量接收，继续使用这个返回值做其他事