Python 函数

1、定义

函数是实现某个功能的一段代码

2、作用

• 方便维护，模块设计
• 减少代码冗余的
• 维护方便

3、参数分类

3.1 按定义分

形参

函数定义的时候，指定的参数

实参

函数调用的时候，传递的参数

参数顺序要求

• 形参顺序
  func01（必选参数，可变长位置参数，默认参数，可变长关键字参数）
• 实参顺序
  fun01（位置参数，关键字参数）

3.2 按形参分

a )必选参数

调用的时候一定要传的参数

def studentinfo(name, age, sex):  # 形参 必选参数
    print(f"my name is {name},my age is {age},my sex is {sex}")

b )默认参数

提供默认值，调用时可填可不填

def studentinfo(name, age, sex="f"):  # sex就是默认参数，默认参数放在必选参数后面
    print(f"my name is {name},my age is {age},my sex is {sex}")

studentinfo("sc", 18)
studentinfo("sc", 18, "m")

c )可变长位置参数

>>> t1 = ("a","b","c")
>>> print(*t1)   #解包
a b c

def myargs(name, *num):
    print(f"{name}:{num}")  # 传递进来的参数默认打包成一个元组
    print(type(num), *num)  #解包，传多少个就打印多少个

myargs("hejin")
myargs("hejin", 1)
myargs("hejin", 1, 2)
myargs("hejin", 1, 2, 3)
结果：
hejin:()
<class 'tuple'>
hejin:(1,)
<class 'tuple'> 1
hejin:(1, 2)
<class 'tuple'> 1 2
hejin:(1, 2, 3)
<class 'tuple'> 1 2 3

d )可变长关键字参数

def myargs2(**num):
    print(num)
    print(**num)  # 这种解包出来为a=1，b=2 是不能够打印输出的


myargs2(a=1, b=2)  #
# 打包：**num: 传参a=1,b=2   —packing —    {"a":"1","b":"2"}
# 解包：**num：  {"a":"1","b":"2"} — unpacking — a=1,b=2 

3.2 按实参分

a )位置参数

按参数顺序依次传递

studentinfo("sc", 18, "f")  # 实参 ，位置参数

b )关键字参数

按key依次传递

def studentinfo(name, age, sex="f"):  # sex就是默认参数,默认参数要放在最后（带等号的都放最后）
    print(f"my name is {name},my age is {age},my sex is {sex}")

studentinfo("sc", 18)
studentinfo("sc", 18, "m")

# 关键字参数
def studentinfo(name, age, sex):
    print(f"my name is {name},my age is {age},my sex is {sex}")

studentinfo("hejin", sex="f", age=18)  # 位置参数一定要放在关键字参数前面

练习：

#可变长位置参数 (*args)
#计算N个数的和（N数量不确定）
def myargs3(*num):
    num_sum = 0
    l = len(num)
    for i in num:
        num_sum += i
    print(f"{l}数之和为：", num_sum)


myargs3(1, 3, 4, 5, 5)

#可变长关键字参数（**kwargs）
#计算N个数的和
#N数量不确定
def myargs4(**num):
    num_sum = 0
    l = len(num.keys())
    for i in num:
        num_sum += num.get(i)
    print(f"{l}数之和为：", num_sum)


myargs4(a=1, b=2, c=3, d=4)

3、 return 语句

退出函数，并且返回结果的
return可以有多个
return可以一次返回多个值
如果一个函数没有return语句，默认返回None
return 后面不接任何表达式，也返回None

def maxnum(x, y):
    print("return语句。。。。。")
    if x > y:
        print("return x")
        return x
    elif y > x:
        print("return y")
        return   #执行这个分支，返回None
    return x, y  #返回值可以用俩个变量接收
    print("return end...")


result = maxnum(3, 4)
i, j = maxnum(5, 5)
print(f"结果：{result},i为{i}，j为{j}")
print(f"结果：{result}")

4、匿名函数（lamada表达式）

不需要创建函数名
只能有一个表达式，不用写return

add2 = lambda x, y: x + y
print(add2(1, 3))
# 可变长位置参数
add3 = lambda *num: sum(num)
print(add3(1, 2, 3))

# 可变长关键字参数
add4 = lambda **num: num

print(add4(a=1, b=2))

# 使用匿名函数返回俩数之间最大值
max_num = lambda a, b: a if a > b else b  #方式1
max_num = lambda a, b:max(a,b)            #方式2
max_num = lambda a, b: x > y and x or y   #方式3
print(max_num(1, 2))

# 使用匿名函数，将传入的浮点数保留俩位小数
float_num = lambda a: float("%.2f" % a)  #方式1
float_num = lambda a: round(x,2)         #方式2
print(float_num(2.33333))

5、递归函数

自己调用自己，形成循环
定义出口条件，什么时候结束递归
通常把一个大问题通过寻找规律可以缩小规模的时候使用的

5.1 阶乘

def func01(n):
    if n == 1:
        return 1
    return n*func01(n-1)
print(func01(3))

5.2 斐波拉契数列

# 斐波拉契数列
def fblq(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fblq(n - 1) + fblq(n - 2)

a = int(input("请输入数列项数："))
str1 = ''
for i in range(a):
    str1 += str(fblq(i + 1)) + ','
print(str1)

5.3 雌雄兔繁殖

1、2 月 1只
3、4月 2只
5、6月 4只
7、8月 8只

# 雌雄兔
def rabbit(n):
    if n == 1 or n == 2:
        return 1
    return rabbit(n - 2) * 2
print(rabbit(8))

6、参数传递

函数的参数传递本质上都是传递引用

6.1 不可变数据类型

def fun1(x):
    print(x)  # 打印1
    x = 100  # 局部变量
    print(x)  # 打印100

x = 1  # 全局变量
fun1(x)
print(x)  # 打印1

6.2 可变数据类型

全局变量在函数里面虽然被修改了，但是引用的地址不变
参数定义的时候，默认参数避免定义成一个可变数据类型

def fun2(a):
    print(a)  # 打印[1, 2, 3]
    a[0] = 100  # 局部变量
    print(a)  # 打印[100, 2, 3]
    
a = [1, 2, 3]  # 全局变量
fun2(a)   
print(a)   # 打印[100, 2, 3]

def f(a=[]):  #调用函数的时候第一次是空列表，再调用就不是了
    a.append(1)
    print(a)
f()
f()
f()

结果：
[1]
[1, 1]
[1, 1, 1]

7、变量的作用域

若全局变量是不可变数据类型，在局部修改全局变量有效 要加global

def f():
    # x = 2 如果你要申明全局变量，就不要再前面定义一个同名的局部变量，会报错
    global x   #申明x为全局变量
    x = 5
x = 1
f()
print(x)   #打印5

8、变量名的解析(LEGB)

• L 在本地变量中 --local
• E 在任意上层函数的作用域 Enclosing function locals
• G 在全局作用域 --global
• B 在内置作用域 --builtin

def f():
    x = 2  #注释掉  x = 1(找G)
    def f2():
        x = 3   #注释掉 x = 2 (找E)
        print(x)  #x = 3  (找L)
        print(__name__)  #__main__
    f2()
x = 1 #注释掉  报错(找B没找到)
__name__ = "sc"  #注释掉 找E 输出__main__
f()

9、注释

文档注释会放在help的描述信息里面
放在函数模块或类里面 第一个用三引号注释的内容

def f():
    """这里是文档注释"""  
    print("hello")
f()
print(help(f))

结果：
hello
Help on function f in module __main__:

f()
    这里是文档注释

None

10、内建函数与工厂函数

内建：Python已经建好了，我们直接调用
内建函数