10、函数介绍、函数参数、函数的返回值

一、函数介绍

　　1、什么是函数

　　ps：函数时用来盛放代码的容器

　　具备某一功能的工具-->函数

　　事先准备工具的过程-->函数的定义

　　遇到应用场景拿来就用-->函数的调用

　　所以函数的使用原则：

　　类似于定义变量

　　先定义

　　后调用

　　

　　2、为何要用函数

　　解决下述问题：

　　1、代码组织结构不清晰、可读性差

　　2、可拓展性差

　　3、如何用函数

　　定义的语法：

　　def函数名（参数1，参数2，参数3...）：

　　"""函数文件的注释"""

　　代码1

　　代码2

　　代码3

　　return 返回值

　　调用的语法

　　一、定义函数

　　发生的事情

　　1、申请内存空间把函数体代码放进去

　　2、将函数内存地址绑定给函数名

　　#强调：定义函数只检测语法，不执行代码

　　

def login():  # login = 函数的内存地址
    print(1111)
    print(2222)
    print(3333)
    print(4444)
    print(5555)

　　x=10 

　　print(X)　　python对于变量有特殊待遇，输出为10

　　print(login)　　输出为ID

二、调用函数：

　　发生的事情：

　　1、先通过函数名定位到函数的内存地址

　　2、函数内存地址（）->触发函数体代码的运行

　　强调：调用函数才会执行函数体代码

　　例1：

　　def func（）：

　　　　print（1111

　　#这里python直接报错，语法错误

　　例2：

　　def func（）：

　　　　print（1111）

　　　　x

　　　　print（2222）

　　func

　　例3：

　　

# ================
def bar():
    print('from bar')

def foo():
    print('from foo')
    bar()

foo()
================
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')

foo()

三、定义函数的三种方式

　　3.1无参

　　

def say():
    print('========')
    print('welcome to here')
    print('========')
say()

def login():
    inp_name = input("username>>>: ").strip()
    inp_pwd = input("password>>>: ").strip()
    if inp_name == "egon" and inp_pwd == "123":
        print('login successful')
    else:
        print("username or password error")

login()

　　3.2有参

　　

def max2(x,y):
    if x > y:
        print(x)
    else:
        print(y)
max2(10,20)

　　3.3空

　　def login（）

　　　　pass

　　#这种方法一般用与罗列整体框架

四、调用函数的三种形式

　　4.1语句

　　len（''hello''）

　　4.2表达式

　　res = len（"hello"）*10

　　print（res）

　　4.3可以当做参数传给另一个参数

　　print（len("hello")）

五、参数

　　总体分为两大类：

　　1、形参：在函数定义阶段括号内指定的参数，称之为形式参数，简称形参-->变量名

　　2、实参：在函数调用阶段括号内传入的值，称之为实际参数，简称实参-->变量值

　　形参与实参的关系是：

　　在调用函数时，实参值会绑定给形参名，在函数调用完毕后解除绑定

　　

def func(x,y):
    # x = 111
    # y = 222
    print(x,y)

m=111
n=222
func(111,222)

　　细分的话：

===========================形参系列==============================

　　1、位置形参：在定义函数时，按照从左到右的顺序依次定义的变量名，称之为位置形参

　　特点：内次调用，必须被赋值

def func(name,age):
    print(name)
    print(age)

func(1,2,3)
func(1)#被赋的值一个都不能多,一个都不能少,不然就报错

　　二、默认形参：在定义函数时，就已经为了某个形参赋值了，称之为默认形参

　　　　特点：调用函数时，可以不用为其赋值

　　

def func(name,age=18):
    print(name)
    print(age)
func("egon")
func("egon",19)

　　　　注意：可以混用位置形参与默认形参，但是

　　　　1、位置形参必须在前面

　　　　2、默认形参的值通常应该是不可变类型

　　　　3、默认形参的值实在函数定义阶段赋值的

def func(age=18,name):
    print(name)
    print(age)


def func(name,hobby,hobbies = None):
    if hobbies is None:
        hobbies = []
    hobbies.append(hobby)
    print('%s的爱好是%s' %(name,hobbies))

func('egon','read')
func('tom','play')
func('jack','music')
func('lili','eat',["movie"])


m=1111
def func(x,y,z=m):
    print(x)
    print(y)
    print(z)
m=666#z还是1111
func(1,2)

=========================实参系列============================

　　一、位置实参：在调用函数时，按照从左到右的顺序依次传入的值，称之为位置实参

　　　　特点：按照位置为形参赋值，一一对应

　　　　func（"egon",18）

　　　　func(18,"egon")

　　二、关键字实参：在调用函数时，按照key=value的形式传值，称之为关键字实参

　　　　#特点：可以打乱顺序，但是任然能够指名道姓的为指定的参数赋值

　　func（age=18,name="egon"）

　　　　注意：可以混用位置实参与关键字实参，但是

　　　　1、位置实参必须在关键字实参的前面

　　　　2、不能为同意形参重复赋值

func("egon",age=18)
func(age=18,"egon")   # 语法错误

def foo(x,y,z):
    pass

foo(1,y=2,3)  # 错误
foo(1,y=2,z=3,x=4)  # 错误

　　可变长系列：

　　可变长参数值的是在调用函数时，传入的参数个数不固定，对应着必须有特殊形式的形参来接收溢出的实参

　　实参无非两种形式

　　　　溢出的位置实参-->*

　　　　溢出的位置关键字实参-->**

=========================*与**在形参中事一种汇总行为===================

　　1、*在形参中的应用：*会将溢出的位置实参合并成一个元组，然后复制给紧跟其后的那个形参名

def func(x,*args):  # y = (2,3,4,5)
    print(x)
    print(args)

func(1,2,3,4,5)


def my_sum(*args):
    res = 0
    for i in args:
        res += i
    print(res)

my_sum(1,2)

　　2、**在形参中的应用：**会将溢出的关键字实参合并成一个字典，然后复制给紧跟气候的那个形参名

　　

def func(x,**kwargs):  # kwargs = {"a":2,"c":4,"b":3}
    print(x)
    print(kwargs)

func(1,a=2,b=3,c=4)

=========================*与**在实参中是一种打散行为====================

 　　*在实参中的应用：*后可以跟可以被for循环遍历的任意类型，*会将紧跟其后的那个值打散成为位置实参

def func(x,y,z):
    print(x)
    print(y)
    print(z)


func([11,22,33])
func(*[11,22,33])  # func(11,22,33)
func(*"hello")  # func("h","e","l","l","o")
func(*{"k1":111,"k2":2222})  # func("k1","k2")

**在实参中的应用：**只能跟字典类型，**会将字典打散成关键字实参
func(**{"k1":111,"k2":2222})  # func(k2=2222,k1=111)
func(**{"x":111,"y":2222,"z":333})

　　

例：
def index(x,y,z):
    print(x,y,z)

def wrapper(*args,**kwargs):  # args=(1,2,3,4,5,6)  kwargs={"a":1,"b":2,"c":3}
    index(*args,**kwargs)  # index(*(1,2,3,4,5,6),**{"a":1,"b":2,"c":3})
    #                        index(1,2,3,4,5,6,a=1,b=2,c=3)
# wrapper(1,2,3,4,5,6,a=1,b=2,c=3)
wrapper(1,y=2,z=3)

　　了解（**）：命名关键字形参：在*与**中间的形参称之为命名关键字形参

　　　　特点：必须按照key=value的形式传值

def func(x,m=333,*args,y=222,z,**kwargs):
    print(x)
    print(args)
    print(y)
    print(z)
    print(kwargs)

func(1,2,3,z=4,a=1,b=2,c=3)
func(1,2,3,4,5,6,7)

 

函数的返回值

　　

def max2(x,y):
    if x > y:
        return x
    else:
        return y

res = max2(10,20)
print(res * 12)

　　return详解：

　　1、函数可以有多个return，但只要执行一次return，整个函数就立即结束，并且将return后的值当做本次调用的结果返回

def func():
    print("=====")
    return 111
    print("****")
    return 222
    print("----------")
    return 333

res = func()
print(res)

　　2、return后的返回值有三种情况

　　（1）return值：返回的就是这一个值

　　（2）return 值1，值2，值3：返回的是一个元组

def func():
    return 111,"xxx",[22,33]

res = func()
print(res)

　　（3）函数内可以没有return、或者return None、或者return：返回的都是None

　　

def func():
    print(111)
    return
    print(2222)


res = func()
print(res)