05-函数

• 函数的参数：必备参数、默认参数、不定长参数(*args元组和**kwargs字典)
• 知识点：

1. def定义函数：后面接函数名() 括号中可以定义参数,函数调用是函数名()进行调用，有参数就传参数。
2. 函数参数：三种 必备参数(必须传递)，默认参数(有传入就是传入的值，没有就是默认值)，不定长参数(*args 接收多余的不是键值对a=x形式的放入到元组中的，不定长 **kwargs 接收最后的键值对a=x,b=y形式的不定长)。
3. 函数作用域： 函数内部不能直接修改函数外部的变量，如果需要则用global声明全局变量。 内层函数不能直接修改外层函数的变量，如果需要则用nonlocal声明局部变量。外部不能直接使用函数内的变量和内层函数，如果需要用，用闭包形式返回出去。
4. 递归函数：函数自身返回自己的调用 必须有结束条件 也要注意递归深度
5. 匿名函数：lambda 不需要写函数名 会自动返回数据，一般结合其他函数一起使用。

一 函数的定义和调用

# def是关键字，function是函数名，括号内是参数
# print只是单纯的打印，如果需要把值返回出去，使用return返回值，return是一个函数中最后执行的语句。
def function(x,y):
    print('x is',x)
    print('y is',y)
    return x+y
function(1,2) # 调用

二 函数参数

# 友好的提示：  -> (类型：str,int,None,dict,set...)
def func(x, y=100, *args, **kwargs) -> int:
    print(x)
    print(y)
    print(args)  # (30, 40, 'a', [1, 2], {'b': 1})
    print(kwargs)  # {'name': 'moran', 'age': 18}
    return x * y

a = func(10, 20, 30, 40, 'a', [1, 2], {'b': 1}, name='moran', age=18)
print(help(func))  # help()查看函数或模块用途的详细说明

三 函数作用域

• global 全局变量
• nonlocal 局部变量

num = 100

def func():
    global num # 声明全局变量
    num = num*10 # 全局变量修改之前需提前声明全局变量
    print(num)

def laowang():
    tv = 100
    def son1():
        nonlocal tv # 声明局部变量
        tv += 10 # 内层函数修改外层函数时，需提前声明局部变量
        print(tv)
    def son2():
        nonlocal tv # 声明局部变量
        tv += 10
        print(tv)
    return son1()

四 闭包

# 闭包： 外层函数返回内层函数的函数体
def func():
    lv = 1
    def add():
        nonlocal lv
        lv += 1
        return lv
    def sub():
        nonlocal lv
        lv -= 1
        return lv
    return add,sub

add,sub = func() # 元组

五 递归函数

# ----递归函数：函数自己调用自己
def recursion(n):
    if n == 0: # 递归的结束条件
        return 1  
    
    else:
        return recursion(n - 1) * n
print(recursion(5))
# 递归深度

六 匿名函数、内置函数、函数回调

# ----匿名函数
li = [1,2,3,'4','a','b']
li.sort(key=lambda x:str(x))

# ----内置函数
# ord() 返回对应的 ASCII 数值
print('a的ascll码值：',ord('a'))

# chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符
print('66对应的：',chr(66))

# len() 返回对象（字符、列表、元组等）长度或项目个数
print(len([1,2,3]))

li = [1,2,3,4,5,6,7,8,9]

def func(x):
    if x>5:
        return x

# --filter:过滤器
ft = filter(func,li)
print(list(ft))
ft1 = filter(lambda x:x>5,li)
ft2 = filter(lambda x:x%2==0,li)
print(list(ft1))

def func(x):
    if x%2==0:
        return x*100
    else:
        return x*10

# # --map:统一操作(计算)
map1 = map(func,li)
map2 = map(lambda x:x*100 if x%2==0 else x*10,li)
print(list(map1))
print(list(map2))

li1 =[]
def func(x):
    if x>5:
        li1.append(x)
for i in li:
    func(i)
print(li1)

# ----函数回调：把一个函数的函数体当作参数 传递给另外一个函数
def func(f):
    f()  # 可用可不用
    print('这是func调用')
        
def play():
    print('这是play')
func(play)

七 练习

def sort1():
    li = [(2, 4, 6, 7), (1, 2, 3, 4), (3, 4, 5, 6), (6, 2, 5, 8)]
    # li.sort(key=lambda x: x[1], reverse=False)
    def func(x):
        return x[1]
    li.sort(key=func)
    print(li)

# 判断是否是质数
def isPrime(param):
    print(type(param))
    # isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
    # isinstance (a,(str,int,list))    # 是元组中的一个返回 True
    # if str(param).isdigit() == False:
    if isinstance(param, int) == False:
        print('参数是整数，请重新输入！')
    elif param <= 1:
        print('质数大于 1')
    elif param == 2:
        return True
    else:
        # 只能被自身和1整除
        for i in range(2, param):
            if param % i == 0:
                print(f'{param}不是质数')
                return False
        else:
            print(f'{param}是质数')
            return True

# 阶乘函数  正负阶乘
def factorial(param):
    if param == 0:
        print(f'{param}=', end='')
        return 1
    elif param < 0:
        print(f'{param}*', end='')
        return param * factorial(param + 1)
    else:
        print(f'{param}*', end='')
        return param * factorial(param - 1)
a = factorial(-8)

def issort2(st):
    if list(st) == sorted(st):
        return 'UP'
    elif list(st) == sorted(st,reverse=True):
        return 'DOWN'
    else:
        return False
issort2('abcd')