Python 函数

函数就是一段可以重复多次调用的代码，通过输入的参数值，返回需要的结果。

函数的定义

函数在使用前必需定义，使用关键字def定义，函数的类型即返回值的类型。

def 函数名(形参1,形参2,...,形参n):
    代码块
    return 表达式

注意：函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)，函数的参数放在一对圆括号中，可以是一个或者多个参数，参数之间用逗号隔开，这种参数称为形式参数。

参数

• 形参与实参
  形参：定义函数时声明的变量，放在一对圆括号中
  实参：指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参，否则将出现错误，具有默认值的参数例外。

# 定义函数，声明变量a,b，这两个变量会在函数内部被用到,给变量b声明默认值3
def fun(a,b=3):
    print(a+b)

# 调用函数，传递实参,实参与形参一一对应的关系 1传给a, 2传给b
fun(1,2)

# 调用函数，传递实参，因为在定义函数给b设置了默认值，所以在调用时传递一个实参给a
fun(1)

实参可以是任何数据类型，包括传入函数对象

def Test():
    pass

def fun(a):
    print(a)

fun(1)
fun("string")
fun((1,2,3))
fun([1,2,3])
fun({1,2,3})
fun({"1":"1"})
fun(Test)

• 参数的传递方式
  定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。 如果用户没有传递，则默认值就会生效 (上面的代码已经展示）

位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去

# 定义函数
def fun(a,b=2,c=2):
    print("a=",a)
    print("b=",b)
    print("c=",c)

# 位置传参，一一对应
# 传递一个实参，变量b，c会使用默认值
fun(2)
'''
a= 2
b= 2
c= 2
'''
# 传递三个实参,实参3,4,5会一一对应的传递给形参a,b,c.
fun(3,4,5)
'''
a= 3
b= 4
c= 5
'''
# 关键字传参,实参通过形参变量指定传递
fun(a=5,b=6,c=7)
'''
a= 5
b= 6
c= 7
'''
# 位置传参与关键字传参的混合使用，这里要注意位置传参必须放到关键字传参的前面

'''
fun(a=2,4,5) 关键字传参放在位置传参前面，python解释器报错
SyntaxError: positional argument follows keyword argument
'''
# 把关键字c 放在最后面传参就没有问题
fun(2,4,c=5)
'''
a= 2
b= 4
c= 5
'''

• 不定长参数
  定义函数时，可以在形参前面加符号 * 来接收所有的实参，不定长参数主要分为位置传参的不定长参数 和 关键传参的不定长参数。

def 函数名(*args, **args):
    代码块

位置传参的不定长参数，用一个 * 表示，将所有的实参保存在一个元组里面，不能接收关键字传参。一个函数里面包含 * 的形参只能有一个，可以和其他参数配合使用

# 通过代码解释一下位置传参，位置传参的不定长参数，关键字传参
def fun(a,b,c,d):
    print(a,b,c,d)

def fun1(*e):
    # 这边通过打印 e 可以看到是以元组的方式接收 4个实参
    print(e)
    for i in e:
        print(i)

fun(1,2,3,4)
fun1(1,2,3,4)

# 定义一个位置参数，位置不定长参数混合使用的函数
'''
def fun2(*f,g):
    print(g)
fun2(1,2,3,4)
上述fun2的调用，python解释器会报错 TypeError: fun2() missing 1 required keyword-only argument: 'g'
形参g会获取不到我们预想的实参4的引用传递，位置传参不定长传参f会把所有的参数都获取，所以我们可以把形参g 放到 f 前面
def fun2(g,*f):
    print(g)
fun2(4,1,2,3)
实参4 传递给了形参 g, 不定长参数f 接收了后面的1，2，3.
'''
# 定义一个关键字传参与位置传参不定长参数的混合使用
'''
def fun2(*f,g):
    print(g)

#这里给形参g指定参数传递，所以不定长f接收了 1，2，3，
fun2(1,2,3,g=4)
'''
# 位置传参，关键字传参，位置传参不定长参数的混合使用，位置传参e接收1，不定长传参 f 接收 (2,3), g接收4
# 由于之前学过在函数调用的时候，实参 关键字传参必需放在位置传参后面，这里依然遵守这一条，位置传参不定长参数依旧属于位置传参，
# 所以在定义函数时 形参 位置传参不定长必需放到关键字传参前面
def fun3(e,*f,g):
    print(e)
    print(g)
fun3(1,2,3,g=4)

关键字传参不定长参数 形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值, **形参只有一个，并且必须写在所有参数的后面。

def fun4(g,**e):
    print(e)
    print(g)

# 位置传参与关键字不定长传参，位置传参要放在前面
fun4(5,a=1,b=2,c=3,d=4)

# 关键字传参与关键字不定长传参，关键字传参要放在关键字不定长参数前面（g, **f), g 要放在前面，不然**f会接收所有的实参
fun4(a=1,b=2,c=3,d=4,g=5)

• 参数的解包
  传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递，要求序列中的元素的个数必须和形参的个数一致

def fun(a,b,c,d):
    print(a,b,c,d)

tuple1 = (1,2,3,4)
# 给序列前面加符号*，元组的元素个数和函数定义的实参个数一一对应
fun(*tuple1)

# 对于字典类型的参数，可以用关键字不定长参数的方式理解,(关键字传参）
dict1 = {'a': 1, 'b': 2, 'c': 3,'d':4}
fun(**dict1)

返回值

返回值就是函数执行以后返回的结果
通过return来指定函数的返回值
return后面可以跟任意对象（数据类型或者表达式），返回值甚至可以是一个函数

注意如果函数代码块中没有return语句，即函数没有返回值，python也不会报错，依然可以获得返回值None, None也是python的一个对象，不属于数字也不属于字符串，当return语句不带任何参数时，返回的也是None，函数体内遇到return 语句（return后面的语句不执行）

# 函数体没有return语句
def fun():
    pass
print(fun())
# None

def fun1():
    return
print(fun1())
# None

# 函数体内碰到return 就返回，print(2)不会执行
def fun2():
    print(1)
    return
    print(2)

print(fun2())
#1
#None

文档字符串

help()是Python中内置函数，通过help()函数可以查询Python中函数的用法
在定义函数时，可以在函数内部编写文档字符串，文档字符串就是对函数的说明（说白了就是""" “”"包含的内容

"""
# 长字符串 ：
1. 保留文本的格式
2. 作为一个多行注释
3. 文档字符串，文档说明
"""

def fun(a,b):
    '''
    :param a:
    :param b:
    :return:
    '''

help(fun)

控制台有如下输出，输出函数对象的解释说明

Help on function fun in module __main__:

fun(a, b)
    :param a:
    :param b:
    :return:
    
Process finished with exit code 0

作用域

作用域指的是变量生效的区域，python中有两种作用域

• 全局作用域
  全局作用域在程序执行时创建，在程序执行结束时销毁
  所有函数以外的区域都是全局作用域
  在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问
• 函数作用域
  函数作用域在函数调用时创建，在调用结束时销毁
  函数每调用一次就会产生一个新的函数作用域
  在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问

# 定义全局变量 a，作用域整个程序
a=10
# 定义函数
def fun():
    # 函数内部定义局部变量 a，作用域函数内部,a重新赋值为20、，
    a=20
    print(a)

# 打印局部变量的值
fun()
# 这边打印出来的依旧是全局变量10，因为局部变量a的作用域仅仅是在函数fun内部
print(a)

怎么使函数内部的变量a的作用域 扩展到全局作用域呢？

有，用global关键字？下面这段代码函数内部修改了全局变量的值。

# 定义全局变量 a，作用域整个程序
a=10
# 定义函数
def fun():
    global a # 声明 此处的a 用的是全局变量
    a=20
    print(a)

# 打印函数内部的变量值
fun()
# 这边打印出来的为20，因为 global 关键字改变了函数内部 变量a的作用域，而且重新赋予了值，
print(a)

命名空间 （用的不多，了解下概念就好）

命名空间实际上就是一个字典，是一个专门用来存储变量的字典
locals()用来获取当前作用域的命名空间
如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间
返回值是一个字典

练习：

1. 打印名片程序:输入姓名，电话号码，性别，最后打印出来名片
   • 控制姓名长度为6-20
   • 电话号码长度11
   • 性别只能允许输入男或女
   • 每一样信息不允许为空

# 打印名片，命名定义为一个字典
bussinessCard = {"姓名":[],"电话号码":[],"性别":[]}
# print(businessCard)
def name():
    while(True):
        name1 = input("请输入姓名:")
        if(6 <= len(name1)<=20):
            bussinessCard["姓名"].append(name1)
            break
        else:
            print("姓名的长度应该为6-20")
            continue
def phoneNum():
    while(True):
        num = input("请输入电话号码：")
        if(len(num)==11 and num.isdigit()):
            bussinessCard["电话号码"].append(num)
            break
        else:
            print("电话号码长度11且由数字构成")
            continue

def gender():
    lst = ["男","女"]
    while(True):
        g = input("你的性别：")
        if(g in lst):

            bussinessCard["性别"].append(g)
            break
        else:
            print("性别输入有误！且不能为空")
            continue

name()
phoneNum()
gender()
print("名片信息如下：")
for k,v in bussinessCard.items():
    for i in v:
        print(k,i)

2. 使用函数求前20个斐波那契数列斐波那契数列：1,1,2,3,5,8,13,21…即: 起始两项均为1，此后的项分别为前两项之和

# 定义一个列表
lst = [1,1]

def feibo():
    while(len(lst)<=20):
        lst.append(lst[-1]+lst[-2])
    print(lst)

feibo()

3.编写一段代码，定义一个函数求1-100之间所有整数的和，并调用该函数打印出结果

def sum(n):
    res=0
    for i in range(n+1):
        res+=i
    print(res)

sum(100)

4.用函数实现一个判断用户输入的年份是否是闰年的程序

• 能被400整除的年份
• 能被4整除，但是不能被100整除的年份

以上2种方法满足一种即为闰年

def leapYear(year):
    if(year % 400 ==0):
        print("%d 是闰年" % year)
    elif(year % 4 ==0 and year %100 !=0):
        print("%d 是闰年" % year)
    else:
        print("%d 不是闰年" % year)

year = int(input("请输入要判断的年份："))
leapYear(year)