python函数

函数的概念
函数的参数
函数的返回值
python的内置函数

一、函数的概念

函数：对某个特定的功能或者代码块进行封装，在需要使用该功能的时候直接调用即可

定义：
def 函数的名字()：
被封装的功能或者代码块 ->函数体

调用：
函数的名字()

def xishu(): # 定义函数，不负责运行出来
    print("刷牙。")
    print("洗脸。")
    print("水乳。")
    print("防晒。")

xishu()
print("吃早饭！")
xishu()
print("吃午饭！")
xishu()
print("吃晚饭！")

二、函数的参数

参数：可以在函数调用的时候给函数传递一些信息
分类：

1.形参，在函数定义的时候，需要准备一些变量来接受信息
    1.1.位置参数，按照位置一个一个的去声明变量
    1.2.默认值参数
    1.3.动态传参
        1.3.11.*args，表示接收所有位置参数的动态传参
        1.3.2.**args 表示接受所有的关键字的动态传参
    顺序：位置>默认值参数，可能只是看着好看？
         位置>*args>默认值>**kwargs
上述参数可以随意搭配使用    
2.实参，在实际函数调用的时候传递信息
    2.1.位置参数，按照位置进行传参
    2.2.关键字参数,按照参数的名字进行传递参数
    2.3.混合参数：
        顺序：位置参数放前面，关键字参数放后面
 实参在执行的时候必须要保障形参有数据

• 形参，在函数定义的时候，需要准备一些变量来接受信息
• 实参，在实际函数调用的时候传递信息

# 1. 骂谁 2. 骂到什么程度
def maren(name,degree):  #形参
    print("1. 怒目而视" + name)
    print("2. 严正交涉" + name)
    if degree > 100:
        print("3. XXXX")
    else:
        print("3. 你瞅啥")
    print("4. 骂完收工")

maren("破键盘", 188)   # 在调用函数的时候才知道骂谁，骂到什么程度 ->实参
maren("破鼠标", 10)
maren("破电脑", 999)

#请用函数编写一个计算器，+ - * /

def computer(a, op, b):
    if op == '+':
        print(a + b)
    elif op == '-':
        print(a - b)
    elif op == '*':
        print(a * b)
    elif op == '/':
        print(a / b)
    else:
        print("输入格式不对")

computer(1, '+',1000)
computer(1, '/',1000)
computer(1, 'hhhhh',1000)

2.1.位置参数，按照位置进行传参

def chi(zhu, fu, tang, tian):
    print(zhu, fu, tang, tian)

# chi("米饭")   #chi() missing 3 required positional arguments: 'fu', 'tang', and 'tian',所有参数都必须有值才行
chi("米饭", "辣椒炒肉", "豆浆", "哈根达斯")

2.2.关键字参数,按照参数的名字进行传递参数

chi(zhu= "米饭", tang= "豆浆", fu= "辣椒炒肉", tian ="哈根达斯")

2.3.混合参数：
顺序：位置参数放前面，关键字参数放后面

#关键字参数需要写在位置参数后面，如果写在前面顺序打乱的话，那按照位置来看当时的位置已经有参数了，而且关键字参数占了那个位置，那个位置就没有参数传进去了。
chi("米饭","辣椒炒肉",  tian ="哈根达斯", tang= "豆浆")
# chi(zhu= "米饭","辣椒炒肉",  tian ="哈根达斯", tang= "豆浆") #positional argument follows keyword argument

# open("人名单.txt",mode='xx', encoding='xxx')   #典型的混合参数

1.2.默认值参数

def msg(name, age, gender = '女'):
    print(name, age, gender)

msg("甄嬛", 17)
msg("沈眉庄", 18)
msg("允礼", 25, '男')
msg("温实初", 25, '男')
msg("安陵容", 16)
msg("年世兰", 20)

print("hhhhhh",end=' ')
print("llllllllllll")#print函数默认最后跳行

1.3.11. * args，表示接收所有位置参数的动态传参

def chi(*food): #*表示位置参数的动态传参，*接收到的值会统一放在一个元组里面
    print(food)

chi("米饭", "辣椒炒肉", "豆浆", "哈根达斯")
chi("米饭", "辣椒炒肉")
chi("米饭", "辣椒炒肉", "豆浆", "🍦","🍉")

1.3.2. ** args 表示接受所有的关键字的动态传参

def chi(** food):   # **表示接受关键字动态传参，接收到的所有参数都会被处理成字典
    print(food)
# 只接受关键字实参
# chi("dd",fu = '辣椒炒肉', tang = '甜牛奶') #chi() takes 0 positional arguments but 1 was given

chi(zhu= "粉丝方便面两掺", tang= "甜牛奶", fu= "辣椒炒肉", tian ="哈根达斯")

顺序：位置>默认值参数，可能只是看着好看？

• 位置>*args>默认值>**kwargs

def func(a,b,c='llll', *args, **kwargs):
    print(a,b,c,args,kwargs)

func(1,2,3,4,5,6,7,)#args接收第四位以后的所有参数
func(1,2,3,4,5,6,7,hello = 123)#kargs接收关键字参数
# func(1,2,hello = 123,3,4,5,6,7)# kargs占据了位置参数的位置，无法传参


def func(a,*args,b=888,c=6666,**kwargs):
    print(a,b,c,args,kwargs)
#1之后所有数字都传给了args，b和c无法传参,如果要改变b和c的值可以进行关键字传参
func(1,2,3,4,5,6,7, b=999)#func() missing 2 required keyword-only arguments: 'b' and 'c'

def func(a,b=888,*args,c=6666,**kwargs):
    print(a,b,c,args,kwargs)
# 如果默认值在args前面，那么默认值相当于没有设置，因为它也是一种位置参数，args也需要传参，那么args的参数就给了默认值，那默认值的存在就没有用处
func(1,2,3,4,5,6,7)

def func(*args, **kwargs):  #没有限制的接收任何参数，当然关键字在位置后面
    print(args, kwargs)

func()
func(2,3,3333)
func(a = 2)#这是关键字传参，不是赋值运算emmm
func(True)

列表和字典打散传参

lst = ["路飞", "索隆", "娜美", "山治"]
def func(*args):
    print(args)

func(lst)
func(*lst)# *在实参位置可以把列表打散，解构然后再一个一个传给args，和for循环以及赋值函数有点像

dic = {'1': '路飞', '2': "索隆"}
def func(**kwargs):
    print(kwargs)

    # print(kwargs)

# func(dic) #func() takes 0 positional arguments but 1 was given
func(**dic)#keywords must be strings

三、返回值

关于return：
函数值要执行到了return，函数就会立即停止并返回内容，函数内的return的后续代码不会执行

def func(*args):
    return
func()

def func():
    print(123)
    return  #会让程序停止，后续代码不会继续执行，像循环里的break
    print(456)


print(func())

1.如果函数没有return，此时外界收到的是None
比如print()
2.如果写了return
2.1 只写了return，后面不跟数据，此时接收到的依然是None

def func(*args):
    return
func()

2.2 return 值，此时表示函数有一个返回值，外界能够收到一个值

def func(a,b):
    return a+b

print(func(3,4))
print(func(3,4) * 3)

2.3 return 值1，值2，值3… ，此时函数返回多个返回值，外界收到的是元组，并且该元组内存放所有的返回值

def func():
    return  1,2,3,4,'hhhh'

print(func())