Python语法学习之函数

#函数
#什么是函数  在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用
#所以把具有独立功能的代码块组织为一个小模块，这就是函数
#函数定义和调用
#格式
# def 函数名():
# 执行语句
# 函数名() #调用函数

def fun1():
    print("hello wordl")
fun1()
#函数参数
def fun2():
    a=1
    b=2
    c=a+b
    print(c)
fun2()

#位置参数
# 定义时小括号中的参数，用来接收参数用的，称为 “形参”
# 调用时小括号中的参数，用来传递给函数用的，称为 “实参”
# def 函数名(参数1,参数2):
# 代码块
# 函数名(值1,值2)
def fun3(a,b):
    print("a",a)
    print("b",b)
fun3(2,6)
#关键字参数
#格式def 函数名(参数1,参数2):
# 代码块
# 函数名(参数1=值1,参数2=值2) 如果关键字参数传参要在位置参数之前，将会报错
def fun4(a,b):
    print("a", a)
    print("b", b)
fun4(6,b=9)
fun4(a=6,b=9)

#缺省参数  在形参中默认有值的参数，称之为缺省参数
#调用函数时，缺省参数的值如果没有传入，则取默认值（形式参数），如果传入，则取实际参数
#缺省参数一定要位于位置参数的最后面
def fun5(name,age=11):
    print("name:",name)
    print("age:",age)
fun5(name="jack",age="111")

#2.3.4:不定长参数
#时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。
# def printinfo(*args,**kwargs):
# print("args:",args)
# print("kwargs:",kwargs)
# printinfo(参数)
# 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组

def fun6(*a):
    print("数据",a)
fun6(100,222,22244,555,333)
# 而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典
def fun7(*a,**b):
    print("数据",a)
    print("数据",b)
fun7(22222,33,33,name='张三',age=19)
#参数位置顺序
#格式
# def fun(位置参数,*args,缺省参数,**kwargs):
# 代码块
# fun(参数值)
def fun8(a,*b,**c):
    print("第一个参数", a)
    print("元组类型", b)
    print("字典类型", c)
fun8(22222,33,33,name='张三',age=19)

# 如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到 *args的后面， 但如果有
# **kwargs的话，**kwargs必须是最后的
def fun9(d,*a,qww=1,**c):
    print("第一个参数D：", d)
    print("元组类型：", a)
    print("缺省类型qww：", qww)
    print("字典类型c：", c)
fun9(22222,33,33,qww=19,name='张三',age=19)
#函数返回值
#格式
# def sum():
# 代码块
# return 值
# sum()
#代码
def fun10(q,w):
    return  q+w
r=fun10(1,2)  #保存函数的返回值
print(r)
#多个return
# 一个函数中可以有多个return语句，但是只要有一个return语句被执行到
# 那么这个函数就会结束了，因此后面的return没有什么用处
def fun11(num):
    print("第一行")
    if num==100:
     return  num+1
    else:
     return  num+2
aw=fun11(100)
print(aw)
# aw1=fun11(200)
# print(aw1)
#返回多个数据
#return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据
def aaw(a,b):
      qw=a//b
      qy=a%b
      return  qw,qy
ww= aaw(5,2)
print(ww)

#函数类型
# 1. 无参数，无返回值
# 2. 无参数，有返回值
# 3. 有参数，无返回值
# 4. 有参数，有返回值
# 计算1~num的累积和
def fun12(num):
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
    return result
print(fun12(100))
#函数的嵌套
def fun13():
  print("开启执行")
  print("执行中")
  print("结束执行")
def fun14():
  print("嘟嘟嘟")
  fun13()
  print("啦啦啦")
print(fun14())

#写一个函数求三个数的和，并返回结果
# def  fun15(a,b,c):
#     return   a+b+c
# def fun16(a,b,c):
#     d=a+b+c
#     return  d/3
# def fun17():
#     v= avg(1,2,3)
#     return 1-v,2-v,3-v
# print(fun17())
#写一个函数打印一条横线
def fun18():
  print("_"*20)
fun18()
#打印多条
def fun19(num):
    i=0
    while i<=num:
     fun18()
     i+=1
fun19(4)

#匿名函数 lambda函数可以赋值给变量，默认是返回的，所以不用再加return关键字
g=lambda x :x+1
print(g(1))
#变量 局部变量，就是在函数内部定义的变量
#约束 其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
def fun20():
    a = 120
    print("我是局部变量a:",a)
    a = 240
    print("修改之后的局部变量a:",a)
def fun21():
    a  =360
    print("我是test02函数中的局部变量a",a)
fun20()
fun21()
#  全局变量
#定义 在函数外边定义的变量叫做全局变量
#约束 全局变量能够在所有的函数中进行访问
a = 100
def test1():
    print(a) # 虽然没有定义变量a但是依然可以获取其数据
def test2():
    print(a) # 虽然没有定义变量a但是依然可以获取其数据
# 调用函数
test1()
test2()
#：全局变量的修改 global的使用
#在函数中出现global 全局变量的名字 那么这个函数中即使出现和全局变量名相同的变量名 = 数据
#也理解为对全局变量进行修改，而不是定义局部变量
#在一个函数中需要对多个全局变量进行修改，那么可以使用  还可以用多次global声明都是可以的
#global a, b

a = 100 #全局变量
def test1():
    global a #将a变成全局变量
    a= 300
    print("修改后的a",a)
def test2():
    print(a)
# 调用函数
test1()
test2()