python函数

一.函数的优点

使代码模块化

代码复用，减少冗余

保证了代码的一致性

python中的函数分为内置函数和自定义函数

内置函数: 如int(), str(), len(), range(), id(), max(), print()等,所有的内置函数参考

本章节来说说自定义函数的定义和使用

二.函数的定义和调用

定义格式：

def 函数名(参数列表)：

　　语句1

　　语句2

　　...

参数列表可以为空，但是括号不能省略

理解形参,实参,位置参数,关键字参数

# 无参定义
def say_hello():    #函数定义
    print("hello dear.")


say_hello()     # 函数调用


# 带有参数的定义
def get_max(a, b):      # 形参(形式参数)
    if a > b:
        print(a)
    else:
        print(b)


get_max(3, 5)       # 传递实参，与形参位置对应，个数也与形参相对应，会按顺序传参(位置参数)
get_max(b=5, a=12)  # 关键字参数调用，这里就可以与参数顺序无关了

输出结果
hello dear.
5
12

默认值参数：就是不传参数，会用默认的值，传了参数的就会使用传的参数

def connect_mysql(host, user, password, port=3306):    # port=3306为默认参数
    pass                            # pass就类似一个占位符，保证函数完整，没有语法错误


host = input("input host:")
user = input("input user:")
password = input("password")

connect_mysql(host, user, password)            # 不用再传port的值的,默认就是3306;也可以传一个新的值替代3306

可变长参数：参数的个数不确定，理论上有无限多个，但一般不会超过6或7个

# 可变长参数
def get_sum(*num):      # 求和，参数名前面加*(变量名可以自定义)就可以定义为可变长参数
    summ = 0
    for i in num:
        summ += i
    return summ


print(get_sum(1, 2, 3, 4, 5, 6, 7, 8, 9))


def print_alpha(*args):     # 打印字符串
    for i in args:
        print(i)


print_alpha("a", "b", "c")

输出结果
45
a
b
c

多个关键字参数转字典

def test(**kwargs):            # **两个后面加变量(变量名可以自定义)，这样后面传多个值(需要传关键字参数)，并且结果为字典
    print(kwargs)

    
test(name="zhangsan", age=18, gender="M")

def people(name, *args, age=18, **kwargs):
    print(name)
    print(args)
    print(age)
    print(kwargs)

    
people("zhangsan", "man", 25, salary=20000, department="IT")
people("zhangsan", "man", 180, age=25, salary=20000, department="IT")
people("zhangsan", "man", 180, 25, salary=20000, department="IT")

三.函数返回值

函数的功能是单一的，一个函数只完成一个功能

调用函数时，函数执行完成会有一个执行结果，将执行结果返回给调用者，函数使用return关键字

当执行到return时，说明函数执行完成，会退出函数

def test(a, b):
    c = a + b
    return c
    print("haha")    # 返回值后面的代码不执行,也就是说函数执行到return就结束了

test(1, 2)        # 再回顾一下，这是函数的调用，执行函数体内的代码，但这样得不到函数返回值

d = test(1, 2)
print(d)            # 这样终于得到函数的返回值了

print(test(1,2))    # 不赋值给变量，直接打印也是可以得到函数的返回值

四.变量的作用域

局部变量和全局变量

name = "zhangsan"       # 全局变量

def change_name():
    name = "lisi"    # 这个变量只能在函数内生效，也就是局部变量(可以说这个函数就是这个变量的作用域)
    gender = "male"

    
change_name()        
print(name)            # 结果为zhangsan
print(gender)        # 这句会报错，因为它是局部变量，在外面调用不了

name = "zhangsan"       # 全局变量

def change_name():
    global name,gender     # 这句可以把name改为全局变量，但不建议这样用，如果多次调用函数，这样很容易混乱，容易与外部的变量冲突
    name = "lisi"
    gender = "male"
    print(name)

    
change_name()        # 这句结果为lisi，调用函数内部的print(name)得到的结果
print(name)            # 这句结果为lisi
print(gender)        # 可以调用gender变量了，能打印出结果

五.装饰器

定义一个简单的装饰器

'''
装饰器：就是把一个函数作为参数，返回一个加强版的函数，实质就是一个返回函数的函数

可用于修改一些函数的功能，但是不能修改原函数
'''

# example 1
def add(a, b):      # 只有求和的功能
    print(a+b)


def poweradd(func):     # poweradd为一个装饰器，返回一个新函数inner，新函数是在add函数的基础上加了新的功能
    def inner(a, b):
        print("hello world")
        add(a, b)
    return inner


f = poweradd(add)
print(type(f))    # <class 'function'>
f(3, 6)

输出结果
<class 'function'>
hello world
9

复杂一点的装饰器，使用@符号

def outer(func):
    def inner(name, age):
        if age < 0:
            age = 0
            func(name, age)     # 执行作为参数传过来的函数
    return inner


# 使用@符号作用于函数，相当于给函数加上装饰器
@outer      # 相当于 myprint = outer(myprint)
def myprint(name, age):
    print("{} is {} years old".format(name, age))

# myprint = outer(myprint)

myprint("xiaoming", -12)

输出结果
xiaoming is 0 years old

定义一个通用的装饰器，当传递多个参数时，也可以使用

def outer(func):
    def inner(*args, **kwargs):
        # 在这里添加新功能修饰传入的函数
        print("***********")

        return func(*args, **kwargs)    # 如果func函数有返回值则在这里返回
    return inner


@outer
def myprint(name, age, sex):
    print("{} is {} years old,and is a {}".format(name, age, sex))


myprint("xiaoming", 23, "man")

输出结果
***********
xiaoming is 23 years old,and is a man