python之函数

print() 打印输出
input() 输⼊
len() 求容器⻓度的
...
函数可以实现⼀个具体的功能

函数的定义和调⽤

#，函数，能够实现一个具体的功能，是名行代码的整合#西数的定义:使用关键字def ,
#def函数名():
# #函数名要遵循标识符的规则，见名知意
#函数代码(函数体)
#函数定义,函数中的代码不会执行，在函数调用的时候,才会执行
# #函数的好处:重复的代码不需要多次书写，减少代码冗余
print( '函数定义前')


#函数的定义，函数的定义不会执行函数中算的代码
def func( ):
    print('好好学习,天天向上')
    print( ' good good study,day day up')
    print('上课认真听讲,不要走神')


print('函数定义后')
#函数调用的时候才会执行函数中的代码 函数名（）
print('函数调用前')
func()      #代码会跳转到函数定义的地方去执行
print('函数调用后')

函数的⽂档说明

#函数的文档说明本质就是注释,告诉别人,这个函数怎么使用的,是干什么事的
#只不过这个注释，有特定的位置书写要求，要写在函数名字的下方
def func( ):
'''
打印输出一个heLLo worLd,
'''
#hanser

    print( ' hello wold ' )

func()
#查看函数的文档注释可以使用heLp(函数名)
# heLp( print)

help(func)

 参数的函数

#定义一个函数，实现两个数的和
def add(a, b):      # a和 b称为是形式参数，简称形参
#a = 10
#b = 20
    c = a + b
    print(f"求和的结果是{c}")


#函数调用，如果函数在定义的时候有形参,那么在函数调用的时候,必须传递参数值#这个参数称为实际参数,简称实参
#在函数调用的时候，会将实参的值传递给形参
add(1， 2)           #函数调用时候的参数,称为实参
add(100，200)        #会将实参的值给到形参
#形参的个数需要和实参的个数对应，相同，不能多，也不能少

 函数传参

位置传参与关键字传参

def func(a, b,c):
    print(f"a: {a}")
    print(f"b: {b}")
    print(f"c: {c}")
#位置传参，按照形参的位置顺序将实参的值传递给形参
func(1，2，3)
#func(3，1，2)
#关键字传参,指定实参给到哪个形参,注意点:关键字必须是函数的形参名
func(a=10，b=20，c=30)
#func(c=10,a=20，b=30)
#混合使用，先写位置传参再写关键字传参
# func(10，b=20，c=30)
# func( a=10，20，30)
#代码会报错
#func( 10，a=30，b=20)
#代码会报错

函数形参

（1）缺省参数

# print( )
#缺省参数,形参.在函数定义的时候,给形参一个默认值,这个形参就是缺省参数
#注意点:缺省参数要写在普通参数的后边
#特点:在函数调用的时候,如果给缺省参数传递实参值,使用的是传递的实参值,如果没有传递,使用默认值
def func(a, b,c=10) :    #形参c称为缺省形参
    prinf(f"a: {a}")
    prinf(f"b: {b}")
    prinf(f"c: {c}")
func(1,2)        #没有给c传递实参,使用默认值10
func(1, 2，3)     # 给c传递实参值,使用传递的数据3

(2)不定⻓参数

def func(args, kwargs):    #两个普通的形参
    print(args)
    print(kwargs)

func(1，2)
func(args=2，kwargs=1)

print( '*·*30)
print( '*·*30)

#在形参前边加上一个*，该形参变为不定长元组形参，可以接收所有的位置实参类型是元组
#在形参前边加上两个**，该形参变为不定长字典形参，可以接收所有的关键字实参,类型是字典
def func( *args，**kwargs) :
    print(args)
    print(kwargs)


func(1，2，3，3，4，5)
func(a=1, b=2,c=3，d=4)
func(1，2，3,a=4, b=5,d=6)

(3)函数形参的完整格式

#普迪形参    缺省形参    不定长元组形参    不定长字典形参
def func(a，b=1):    #先普通再缺省
    pass


def func1(a， b=1，*args):        # 语法上不会报错,但是缺省参数不能使用默认值
    print( 'a', a)
    print( 'b', b)
    print( args)


def func2(a，*args, b=1):        #普通形参不定长元组形参缺省形参
    print( 'a', a)
    print( 'b', b)
    print(args)


def func3(a，*args， b=1，**kwargs):    #普通形参﹑不定长元组形参﹒缺省形参 不定长字典形参
    pass

#func1(1,2，3，4)
#func2(1，2，3，4)
func2(1，2，3，4， b=10)

拆包 

容器中元素数据的个数需要和变量的个数保持⼀致. 

#组包，将多个数据值,组成元组,给到一个变量.
a = 1，2，3
print(a)#(1，2，3)


def func():
    return 1，2 #组包


#拆包:将容器的数据分别给到多个变量，需要注意:数据的个数和变量的个数要保持一致
b, c, d = a#拆包
    # print(b, c, d)
e, f = func( )
print(e，f)

my_list = [10，20]
a, b = my_list
print(a，b)
my_dict = i ' name ' : 'isaac' , 'age' : 18}
a, b = my_dict    # key 值
print(a， b)

引⽤

#可以使用id()查看变量的引用，可以将id 值认为是内存地址的别名
#python中数据值的传递的是引用
#赋值运算符可以改变变量的引用


#将数据10存储到变量a 中，本质是将数据10 所在内存的引用地址保存到变量a中

a = 10
#将变量a中保存的引用地址给给到b
b = a
print(a， b)    #使用print函数打印变量a和b引用中存储的值
print(id(a), id(b))

a = 20

print(a， b)
print(id(a), id(b))

my_dict = i ' name ' : 'isaac' , 'age' : 18}a, b = my_dict# key 值
print(a， b)

局部变量

局部变量的作⽤域（作⽤范围）： 当前函数的内部

局部变量的⽣存周期：在函数调⽤的时候被创建，函数调⽤结 束之后，被销毁（删除）

局部变量只能在当前函数的内部使⽤，不能在函数的外部使⽤

#局部变量，就是在函数内部定义的变量,就是局部变量
#局部变量,只能在函数内部使用，不能在函数外部和其他函数中使用

def func( ):
#定义局部变量num
    num = 100
    print(num)


def func1( ):
    num = 200       #这个num和func中的num是没有关系的
    print( num)


#函数调用
func()
func1()
#探究:局部变量能否在函数外部使用
#print(num)#代码报错，局部变量不能在函数外部访问

全局变量

全局变量： 就是在函数外部定义的变量。

在函数内部可以访问全局变量的值，如果想要修改全局变量的 值，需要使⽤ global 关键字声明

#全局变量:就是在丽数外部定义的变量。

#定义全局变量
g_num = '100'


#1．可以在函数内部访问全局变量    可以直接访阿全局变量的值
def func1( ):
    print(g_num)
#2．不能在函数内部修改全局变量的值  不能直接修改全局变量的值
def func2():
    # g_num = 200#这里不是修改全局变量的值,是定义一个局部变量,和全局变量的名字一样而已
    #想要在函数内部修改全局变量的值,需要使用 global关键字声明这个变量为全局变量
    global g_num
    g_num = 300


func1()
func2()
func1()

返回值

在函数中定义的局部变量，或者通过计算得出的局部变量， 想要在函数外部访问和使⽤，此时就可以使⽤ return 关键 字，将这个返回值返回.

#函数想要返回一个数据值,给调用的地方,需要使用关键字return
#return关键字的作用: 将return后边的数据值进行返回o,程序代码遇到eturn，会终止(结束)执行
#return关键字必须写在函数中
def add(a， b):
    c = a + b
    #想要将求和的结果c，返回,即函数外部使用求和的结果，不在函数内部打印结果
    return c
    print(f'求和的结果是{c}')        #函数遇到return就结束了,不会执行return之后的代码



result = add(1ee,280)
print(f'函数外部获得了求和的结果{result} ')

return 返回多个数据值

程序代码遇到⼀个 return 之后，后续的代码不再执行

def func(a， b):
    c = a + b
    d = a - b
    #需求:想要将c和 d都进行返回
    #思考:容器可以保存多个数据值，那就可以将c和d 放到容器中进行返回
    # return [c, d]
    # return (c, d)
    # return { 'c': c, 'd ' : d }
    #return {e: c,1: d }

return c, d #默犬认是组成元组进行返回的


result = func( 10，20)
print(f"a+b的结果是{result[0]},a-b的结果是{result[1]}")

1. return 关键字后边可以不写数据值， 默认返回 None

def func():

         xxx

return # 返回 None，终⽌函数的运⾏的

2. 函数可以不写 return，返回值默认是 None

def func():

        xxx

        pass

函数的嵌套调⽤

def func1():
    print( 'func1 start ... ')
    print( '函数的其他代码')
    print( ' func1 end ...')
    

#在一个函数中可以调用另外一个函数


def func2():
    print( ' func2 start ....')
    func1()    #函数调用
    print( 'func2 end. . . . ' )

#调用func1( )
# func1()

#调用func2()
func2()

案例

学⽣管理系统

增删改查操作
存储学⽣信息:
 姓名
 年龄
 班级
 性别
 ...
 {'name': 'isaac', 'age': 18, ...}
存储所有的学⽣信息:
 列表: [{}, {}, {}, ....]
功能菜单,业务框架.