函数

函数

为什么要有函数：

提高代码的可读性，避免重复代码，提高代码复用性

函数的本质：

　　函数就是一个变量，保存了函数所在的内存地址

写函数的时候，要尽量以功能为导向，结果最好不要直接在函数中打印（比如len(list),我只想要长度，不需要打印输出）

def len_1(para): # 同样，函数名不能是关键字，函数名命名规则等同变量的命名规则就行了
    count = 0
    for i in para:
        count += 1
    return count  # return 终止函数，并返回一个值 （如果没有return，默认返回None  （等同return None））
a = 'dfdf'
print(len_1(a))

没有返回值：

　　不写return == return None

　　写1个return == return None 但是，写个return 代表终止函数

返回一个值：

　　可以返回任意的数据类型。返回什么 就接受什么

　　当然，我们目的是返回一个相关的参数

返回多个值：

　　用一个变量接收，接收到的是一个元组

　　用多个变量接收，返回值和接收返回值的变量数目要一致  

参数

形参和实参

传参数可以传任意的数据类型，并且传什么，接收什么

而站在传参数的角度上看问题：两种传参方式：

　　第一种：按照位置

　　第二种：按照关键字

如果两种混用，按照先传位置，后传关键字的传参顺序（一般不推荐）

def len_1(para):    # para：参数：形式参数，形参    接收参数
    if len(para) > 2:
        return True
    else:return False
a = 'ab'
len_1(a)      # a:参数：实际参数，实参     传参数、传参
print(len_1(a))

默认参数：

def replace_1(name,age = 18)
    pass
replace_1('zhou')     # 不传年龄参数，就默认18  （默认参数是18）
replace_1(‘zhou’,age = 80)      # 传年龄参数80，   age = 80 

函数默认参数魔性的用法

def lst(li = []):
    li.append(1)
    return li
a = []
print(lst(a))
print(lst(a))
print(lst(a))
print(lst(a))
#[1]
#[1, 1]
#[1, 1, 1]
#[1, 1, 1, 1]

# 类似于列表在函数外面
l = []
def lst(li = l):
    li.append(1)
    return li
a = []                    # a = []  会累加
print(lst(a))
print(lst(a))
print(lst(a))
print(lst(a))

# 实参是列表[],就正常了
def lst(li = []):
    li.append(1)
    return li
print(lst([]))     
print(lst([]))
print(lst([]))          # 每次都让新的[]添加
print(lst([]))
#[1]
#[1]
#[1]
#[1]
# so，魔性的用法：默认参数 尽量避免使用可变数据类型

函数的参数：
　　形参：（定义阶段）
　　　　位置参数
　　　　默认参数
　　　　动态参数
　　实参：（调用阶段）
　　　　位置传参
　　　　关键字传参

动态参数：

def func(*args):   # 参数前面加*，这个参数就变成动态参数
    print(args)      # 如果打印，会发现 接收过来的参数是元组形式
func(1,2,3,4)
#(1,2,3,4)
# 或者：迭代添加参数，迭代参数   *变量名称
li = ‘dfdf’
func(*li)
#('d','f','d','f')   元组
---

def func(a,b,c,*args):   
    print(a,b,c)
    print(args)
    print(*args)
    
func(1,3,2,4,5,6)
#1,3,2                           #位置参数接收完后，剩下的都被*args以元组的方式接收
#(4,5,6)   元组
#4, 5, 6

如果有默认参数，那就放到*args后面

def func(a,b,c,*args):   
    print(a,b,c)
    print(*args)
    
func(1,3,2,4,5,6)
#1,3,2     #位置参数接收完后，剩下的都被*args以元组的方式接收
#(4,5,6)
-------

def func(a,b,c,*args,key = 100):   
    print(a,b,c)
    print(*args)
    print(key)    
func(1,3,2,4,5,6)
#1,3,2
#456
#100
func(1,3,2,4,5,key = 9)
#1,3,2
#4,5
#9

形参的顺序：

            位置   剩余位置    默认（关键字）        关键字（除了默认关键字，剩下的关键字）
def func(a,b,     *args,         key = '11'               **kwargs)

def func(a,b,c,*args,key = 100,**kwargs):
    print(a,b,c)       #1 3 2
    print(args)        #(4, 'a')
    print(key)          #18
    print(kwargs)   #{'m': 6, 'n': 'y'}

func(1,3,2,4,'a',key=18,m = 6,n = 'y')

万能参数：

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

func()

li = ‘abcd’
func(*li)            #'a','b','c','d'
dic = {'name':'kitty','age':18}
func(**dic)     #

li = 'abcd'
def func(*args):
    print(args)
func(*li)                              *变量打散
#('a', 'b', 'c', 'd')


def func(**kwargs):      #**kwargs 只接收关键字，所以调用函数时，括号不能放变量
    print(kwargs)
dic = {'name':'kitty','age':18}
func(name='kitty',age=18)    #只能是关键字参数
func(**dic)  #如果不想重新输入字典的键值对，可以用**dic，把字典打散
#字典打散：'name'='kitty','age'=18