python语法 函数篇

1.函数定义

#def 定义一个函数
def caculator_BMI(weight,height):
    BMI = float((weight / (height ** 2)))
    print("你的BMI指数为：" + str(BMI))
    if 28 > BMI > 25:
        print("你的BMI属于偏胖范围")
    elif BMI >= 28:
        print("你的BMI属于偏胖范围")
    elif BMI <= 18:
        print("你的BMI属于偏廋范围")
    elif 25 >= BMI > 18:
        print("你的BMI属于正常范围")

caculator_BMI(74,1.73)

2.可变长形参

def func1(x, y, *z):
    print(x, y, z)

func1(1, 2, 34, 6, 5)

# 求和功能
def sum(*args):
    res = 0
    for i in args:
        res += i
    return res

ans = sum(1, 2, 4, 5, 6, 7, 8)
print(ans)

# 可变长度的关键字形参
# 用法：**kwargs
#可以塞不同类型变量
def func1(x, y, **kwargs):
    print(x, y, kwargs)

func1(1, y=2, c=3, name="zz", d=5)

def func(x, y, *args):
    print(x, y, *args)

func(1, 2, *(1, 2, 34))

def func(x, y, **kwargs):
    print(x, y, *kwargs)

func(**{'x': 5, 'y': 6, 'z': 9})

def func(*args, **kwargs):
    print(kwargs)
    print(args)

func()

3.装饰器

'''装饰器是Python语言中的一种高级语法，它可以在不改变原有代码的情况下，动态地为函数或者类添加功能。装饰器本质上是一个Python函数或类，它可以接受一个函数或类作为输入，并返回一个新的函数或类，这个新的函数或类通常会在原有功能的基础上增加一些额外的功能。
装饰器的实现原理是利用了Python中的闭包和函数对象特性。在Python中，函数和类都是一等公民，它们可以像普通变量一样被传递、赋值、作为参数和返回值。装饰器实际上就是一个函数，它接受一个函数作为参数，并返回一个新的函数。在返回的新函数中，我们可以添加一些额外的功能，如缓存函数、认证用户、记录日志、计时、权限验证等。然后再将这个新函数返回，从而实现对原有函数的装饰。
装饰器的语法使用`@`符号来表示，例如：
@decorator
def my_function():
    pass
这里的`@decorator`就是装饰器语法，它告诉Python解释器在调用`my_function`之前，先调用`decorator`函数。装饰器函数通常会接收被装饰的函数作为参数，然后返回一个新的函数，这个新函数会在执行原有函数之前或之后执行一些额外的代码。
装饰器可以用于多种场景，如日志记录、计时器、缓存、权限/身份验证、错误处理等。它们使得代码更加简洁、优雅，并且提高了代码的复用性和可维护性。
除了基本的装饰器语法外，还有一些高阶的用法，如带参数的装饰器、类装饰器、多装饰器嵌套等，这些高级用法可以让装饰器更加灵活和强大。例如，带参数的装饰器允许我们给装饰器传递一些参数，比如日志的级别、缓存的大小等；而类装饰器则是使用类来实现装饰器功能，它们接受的参数是一个类，而不是一个函数。
在实际开发中，我们可以根据具体的需求来选择合适的装饰器，并使用高阶用法来实现更加灵活和强大的功能。

'''
import functools

# def square(x):
#     return x*x
#
# def print_running(f,x):
#     print(f'{f.__name__} is running')
#     return f(x)
#
#
# ret=print_running(square,2)

"""
在Python中，*args和**kwargs是用于处理可变数量参数的语法。
*args用于接收任意数量的非关键字参数（位置参数），
**kwargs用于接收任意数量的关键字参数。这两种语法允许函数接受不确定数量的参数，增强了函数的灵活性。
"""

import time
#做一个判断函数运行时间的装饰器
# def decorator(func):
#     def wrapper(*args,**kwargs):#包装器
#         start_time=time.time()
#         result=func(*args,**kwargs)
#         print(f'{func.__name__} is running')
#         end_time=time.time()
#         print(f'{func.__name__} execution time: {end_time-start_time}')
#         return result
#     return wrapper
#
# decorator_square=decorator(square)
# decorator_square(100343244234423423)

"""装饰器生成器是一种在Python中用于创建装饰器的函数，它允许你根据不同的参数来生成不同的装饰器"""
#定义一个装饰器生成器
def timer(threshold):
    def decorator(func):
        @functools.wraps(func)#加上这个语句，输出的就是传进来的函数名，而不是wrapper
        def wrapper(*args,**kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            if end_time - start_time>threshold:
                print(f'{func.__name__} took longer than {threshold}')
            return result
        return wrapper
    return decorator

@timer(0.2)
def sleep_04():
    time.sleep(0.4)

# sleep_04=timer(0.2)(sleep_04)

sleep_04()

3.三元表达式

x=6
y=9
res= x if x>y else y
print(res)

4.语法糖

import time
def count_time(func):
    def wrapper(*args,**kwargs):
        start=time.time()
        func(*args,*kwargs)
        end=time.time()
        print(end-start)

    return wrapper

@count_time
def inside(group,s,z):
    print(f'欢迎来到王者荣耀')
    print(f"你出生在{group}方阵营")
    print(f"敌军还有{s}秒到达战场")
    time.sleep(s)
    print(f"{z}出击")

inside('蓝方',3,'炮车')

5.列表生成式

l=['ty_老坛酸菜','ksf_老坛酸菜','djy_老坛酸菜','bx']
new_l=list(name for name in l if name.endswith("老坛酸菜"))
new_l2=[name for name in l if name.endswith("老坛酸菜")]
print(l)
print(new_l)
print(new_l2)

6.字典生成式

l=[("康师傅_老坛酸菜",5),("统一_老坛酸菜",6),("大今野_老坛酸菜",7)]

res = {k:v for k,v in l if not k.startswith('康师傅')}
print(res)

7.生成器

def func(x):
    print(f'{x}开始执行')
    while 1:
        y = yield None
        print('\n',x,y,'\n')

g=func(1)
g.send(None)

for i in range(100):
    g.send(i)

后面就是依次剩下的数字

8.闭包函数

def f1(x):

    def f2():
        print(x)
    return f2

res=f1(10)
res()