python3 函数

'''
def 函数名（参数）：
    代码
'''


# 必须先定义后使用
# my_print()

# 无参函数
def my_print():
    print("hello world")


my_print()


# 有参函数
def my_add(x, y):
    print(x + y)


# my_add(100, "hello") 语法错误
my_add(100, 200)


# 有返回值函数
def my_add_str(x, y):
    return f"{x} + {y} = {x + y}"


res = my_add_str(100, 123)
print(res)  # 100 + 123 = 223


# 函数的注释
def my_function(x, y):
    '''
    注释内容
    :param x: 第一个参数
    :param y: 第二个参数
    :return: 返回值
    '''
    print(x + y)


help(my_function)
'''
my_function(x, y)
    注释内容
    :param x: 第一个参数 
    :param y: 第二个参数
    :return: 返回值
'''

# 变量的作用域
a = 10


def update_a():
    a = 20


update_a()
print(a)  # 此时还是10,


# 函数内定义的变量默认是局部变量， 如果要修改外部变量，需要使用global
def update_a_1():
    global a  # 通过global声明的为全部变量
    a = 20


update_a_1()
print(a)  # 20


# 函数的返回值，只能返回一个值, 如果返回多个值，则会包装成一个元素
def my_return_multi_value():
    return 1, 2, 100  # 等价于return (1, 2, 100)


a = my_return_multi_value()
print(a)  # (1, 2, 100)


# 关键之参数
def my_key_params(name, age):
    print(f"name is {name} age is {age}")


# 关键字参数必须后面
my_key_params("xiaoming", age=18)  # name is xiaoming age is 18


# 默认值参数
# 默认值参数写最后面

def my_default(name, age=18):
    print(f"name is {name} age is {age}")


my_default("xiaowang")  # name is xiaowang age is 18
my_default(name="xiaoli", age=20)  # name is xiaoli age is 20


# 不定长参数
# 包裹位置传递

def user_info(*args):
    print(args)


user_info("xiaozhang", 18)  # ('xiaozhang', 18)


# 包裹关键字传递
def user_info1(**kwargs):
    print(kwargs)


user_info1(name="xiaozhang", age=100)  # {'name': 'xiaozhang', 'age': 100}


# 函数返回值拆包
def my_multi_value():
    return 1, 2


# 拆包
a, b = my_multi_value()
print(a)  # 1
print(b)  # 2

# 字典拆包 数量必须一致
a, b, c = {"name": "libai", "age": 18, "country": "china"}
print(a)  # name
print(b)  # age
print(c)  # country

# 交换变量的值
a, b = 10, 20
a, b = b, a
print(a)  # 20
print(b)  # 10

# 引用 python中的值都是引用传递
a = 10
b = 20
print(id(a))  # 2147500360208
print(id(b))  # 2147500360528

# 不可变的值传递
a = 10
print(id(a))  # 2845387391504


def my_test(a):
    print(f"my_test id(a) is {id(a)}")  # my_test id(a) is 2845387391504 传递过来的时候地址还是一样的
    a += 1
    print(f"my_test id(a) is {id(a)}")  # my_test id(a) is 2845387391536 一旦修改，地址就变了


my_test(a)
print(id(a))  # 2845387391504

# 可变的引用传递
a = [10, 20]
print(id(a))  # 1970498848640


def my_test(a):
    print(f"id(a) is {id(a)}")  # id(a) is 1970498848640
    a.append(100)
    print(f"id(a) is {id(a)}")  # id(a) is 1970498848640


my_test(a)

print(id(a))  # 1970498848640
print(a)  # [10, 20, 100]

'''
对于可变类型，函数内的修改会影响全局变量，而不可变类型函数的内部修改不会影响外部的变量
可变的类型
    列表
    字典
    集合
不可变类型
    整型
    浮点型
    字符串
    元组
'''

# 即使不可变的变量没在函数内修改也会影响地址
a = 10
print(id(a))  # 1909981381136
a += 20
print(id(a))  # 1909981381776


# 递归函数 自己调用自己的函数
def add_until_to(a):
    if a == 1:
        return 1
    else:
        return a + add_until_to(a - 1)


total = add_until_to(100)
print(total)  # 5050