函数初识

函数

写函数的时候，要尽量以功能为导向，结果最好不要直接在函数中打印（比如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

返回一个值： 可以返回任意的数据类型。返回什么 就接受什么
当然，我们目的是返回一个相关的参数
返回多个值： 用一个变量接收，接收到的是一个元组
用多个变量接收，返回值和接收返回值的变量数目要一致
---------------------------

参数：

形参和实参
传参数可以传任意的数据类型，并且传什么，接收什么
而站在传参数的角度上看问题：两种传参方式：
第一种：按照位置
第二种：按照关键字
如果两种混用，按照先传位置，后传关键字的传参顺序（一般不推荐）

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)
pass

replace_1('zhou',18) 按照位置
replace_1(name = ‘zhou’,age = 18) 按照关键字
replace_1(‘zhou’,age = ‘18’) 先位置，后参数，否则会出错
name是str类型，age是int类型，所以 多个 参数可以分别使用任意数据类型

--------
--------

默认参数

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))
不过发现一个情况，函数定义的参数是个列表，实参也得是列表a = [list]

def lst(li = []):
    li.append(1)
    return li
print(lst([])) 
print(lst([]))
print(lst([])) 每次都让[]添加
print(lst([]))

so，魔性的用法：默认参数 尽量避免使用可变数据类型

------

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

动态参数：

*args  **kwargs

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)
    
func(1,3,2,4,5,6)
#1,3,2                           #位置参数接收完后，剩下的都被*args以元组的方式接收
#(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