函数进阶

总结

• 函数的参数

1. 位置参数和关键字参数

# 1.位置参数和关键字参数
# 根据实参的提供是不同的，将实参分为位置参数和关键字参数
"""
1）位置参数：调用函数的时候让实参和形参在位置上一一对应
2）关键字参数：调用函数的时候以'形参名=值'的形式确定形参对应的实参
3）位置参数和关键字参数混用：位置参数必须在关键字参数前面，同时必须保证每个参数都会有一次赋值
"""

# 关键字参数
def func1(x, y, z):
    print(f'x{x},y{y},z{z}')


func1(x=10, z=30, y=20)
# 混用
func1(10, 20, z=30)
func1(10, y=30, z=20)
func1(10, z=10, y=20)
# func1(x=10, 20, z=30)  # SyntaxError: positional argument follows keyword argument

2. 参数的默认值

# 定义函数的时候可以直接在形参后面用 = 给形参赋默认值
# 有默认值的参数在调用的时候不用传参
# 如果有点默认值有参数，有的没有，那么有默认值的参数必须放在没有默认值参数的后面
def func2(x=10, y=20, z=30):
    print(f'x:{x},y:{y},z:{z}')


func2()
func2(100)
func2(z=300)


def func3(z, y=20, x=100):
    print(f'x:{x},y:{y},z:{z}')


func3(z=500)
func3(100)

3. 参数类型说明

# 无默认值参数的类型说明  -  :类型名
# 有默认值的参数，默认值的类型就是参数对应的类型
def func4(x: str, y=''):
    print(x.split('\n'))
    print(y.replace('you', 'me'))


func4('asdasda', 'youfsdfyou')

4. 不定长参数

"""
1）带*的不定长参数：在某个形参前加*，那么这个形参就是一个不定长参数，可以接收任意多个实参
				带*的参数本质是一个元组，对应的实参是元组中的元素
		注意：带* 的不定长参数必须要用位置参数传参
		
2）带** 的不定长参数： 在某个形参前加**，那么这个形参就是一个不定长参数，他可以接收任意多个实参；
					带**的参数本质是一个字典，对应的关键字参数就是字典中的键值对
		注意：**的不定长参数对应的实参必须使用关键字参数传参
"""
# 定长参数在*的不定长参数前，定长和不定长都是用位置参数传参
def func6(char, x, *nums):
    print(f'char:{char}, nums:{nums}, x:{x}')


func6('+', 10)
func6('-', 12, 34, 45)  # char:-, nums:(34, 45), x:12


# 定长在*的不定长参数后面，定长参数必须使用关键字参数传参
def func7(*nums, char):
    print(f'nums:{nums},char:{char}')


func7(10, 20, char='*')


def func8(*, a, b, c):
    print(f'a:{a},b:{b},c:{c}')


func8(a=10, c=20, b=100)


# 3) **的使用
def func9(**x):
    print(x)


func9()
func9(x=10, a=2, v=30)  # {'x': 10, 'a': 2, 'v': 30}


# 定长参数在**的不定长前，定长既可以用位置参数也可以用关键字参数
def func10(x, **y):
    print(f'x:{x}, y:{y}')


func10(10, a=10, b=20)  # x:10, y:{'a': 10, 'b': 20}
func10(x=100, m=1, n=2)  # x:100, y:{'m': 1, 'n': 2}


# 定长参数不能放在**对应的不定长参数后面
# def func11(**x, y):
#     pass
# 带*的不定长参数和带**的不定长参数可以一起使用，带*的必须放在带**的前面
def func11(*args, **kwargs):
    pass


func11()
func11(10)
func11(a=1)
func11(1, 20, a=100)

• 函数的返回值

1. 返回值

返回值的作用就是将函数内部的数据传递到函数外部

2. 怎么确定函数返回值 - 怎么将函数内部的数据传递到函数外部

在函数体中用return关键字来返回返回值（一个函数只有一个返回值）

什么时候需要返回值：如果函数的功能产生了新的数据，将新的数据返回

3. 怎么获取函数的返回值

获取函数调用表达式的值，就是获取函数的返回值

函数调用表达式 - 调用函数的语句

函数调用表达式的值就是函数返回值，函数返回值能做到事情，函数调用表达式都可以做

def sum2(num1, num2):
    return num1 + num2


result = sum2(1, 2) + 10
print(result)


def func1():
    return {1, 2, 3, 4}


set1 = {2, 3}
set2 = func1()
set1.add(5)
set2.add(5)
print(set1, set2)

# 函数调用过程
"""
第一步：回到函数定义的地方
第二步：传参（用实参给形参赋值，这个时候要保证每个参数都有值）
第三步：执行函数体
第四步：执行完函数体的时候确定返回值
	 （看执行函数体的时候有没有遇到return，如果遇到return，return后面的值是什么，
	   函数返回值就是什么，并且在遇到return的时候函数直接结束。如果没有遇到return
	   函数返回值是None）
第五步：回到函数调用的位置（这个时候函数调用表达式的值才是函数的返回值）
"""
def func3():
    print('++++')
    return
    print('-----')
    print('=======')


print(func3())


# Python的函数只有一个返回值
def func4():
    return 10, 20  # 返回值是元组（10， 20）


print(func4())

# 练习：写一个函数，通过指定方法来计算多个结果
# operation('+', 10, 20, 30) -> 求10+20+30
# operation('*', 3, 4, 5, 6) -> 求3*4*5*6
# operation('-', 10, 3, 4) -> 求10-3-4
# operation('/', 19, 2)  -> 求 19/2
def operation(operator: str, *nums):
    if not nums or operator not in ('+', '-', '*', '/'):
        return None
    if operator == '+':
        sum1 = 0
        for x in nums:
            sum1 += x
        return sum1
    if operator == '*':
        sum1 = 1
        for x in nums:
            sum1 *= x
        return sum1
    if operator == '-':
        sum1 = nums[0]
        for x in nums[1:]:
            sum1 -= x
        return sum1
    if operator == '/':
        sum1 = nums[0]
        for x in nums[1:]:
            sum1 /= x
        return sum1
    

print(operation('+', 10, 20, 30))
print(operation('*', 3, 4, 5, 6))
print(operation('-', 10, 3, 4))
print(operation('/', 19, 2))

变量的作用域

1. 变量的作用域：

已经定义过的变量能使用的范围

根据变量的作用域的不同，将变量分为全局变量和局部变量两种

2. 全局变量

# 没有定义在函数内部或者类里面的变量，就是全局变量
# 全局变量的作用域：从定义开始到程序结束的任何位置都可以使用
# a，b，x都是全局变量
a = 10
for x in range(6):
    b = 20

print('循环外面：', x)


def func1():
    print(f'a:{a}, b:{b}, x:{x}')


func1()

3. 局部变量

"""
定义在函数里的变量就是局部变量（形参也是局部变量）；
局部变量的作用域：从定义开始，到函数结束
"""


# c和d都是局部变量
def func2(c=3):
    d = 100

4. 函数的调用过程就是压栈的过程

调用函数的时候，系统会自动在栈区间为这个函数创建一个临时栈区间，用来保存在函数中产生的数据（局部变量）

当函数调用结束，这个临时栈区间会自动释放（释放之前会将返回值传递到临时栈区间的外部）

5. global

"""
在函数中修改一个全局变量的值或者在函数定义一个全局变量

global 变量名
使用变量
"""
num = 30
m = 100


def func3():
    num = 40  # 不是在修改全局变量num的值，而是定义一个新的局部变量
    print(f'函数内部：{num}')
    global m
    m = 200  # 要在函数中修改一个全局变量的值，需要先用global进行说明
    print(f'函数内部：{m}')


func3()
print(f'函数外部num:{num}')
print(f'函数外部m:{m}')

作业

1. 编写一个函数，计算一个整数的各位数的平方和

# 例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14
def squares(nums):
    str_num = str(nums)
    sum1 = 0
    for x in str_num:
        sum1 += int(x) ** 2
    return sum1

print(squares(12))
print(squares(123))

2. 写一个函数，求一个数字列表中绝对值最大的元素

def absolute(list1):
    list2 = [-x if x < 0 else x for x in list1]
    max_value = list2[0]
    num1 = 0
    for index in range(1, len(list2)):
        if list2[index] > max_value:
            max_value = list2[index]
            num1 = index
    return list1[num1]


list3 = [-23, 100, 89, -56, -234, 123]
print(absolute(list3))

3. 编写函数实现字符串join方法的功能，将指定序列中的元素通过指定字符串合并成一个新的字符串

def splicing(element: str, symbol):
    new_str = ''
    for x in element:
        new_str += x
        new_str += symbol
    new_str2 = new_str[:-1]
    return new_str2


str2 = 'ddaii'
print(splicing(str2, '-'))  # d-d-a-i-i

4. 写一个函数实现列表extend的功能，将指定序列中的元素全部添加到指定列表中

def extend_s(list1: list, se):
    for x in se:
        list1.append(x)


list2 = [10, 20, 30, -10, -20]
extend_s(list2, [1, 2])
print(list2)  # [10, 20, 30, -10, -20, 1, 2]

5. 写一个函数实现简易计算器的功能：输入第一个数字，输入运算符，输入第二个数字，计算结果

def calculator():
    num1 = float(input('数字一：'))
    operator = input('请输入运算符：')
    num2 = float(input('数字二：'))
    if operator == '+':
        print(f'{num1 + num2}')
    elif operator == '-':
        print(f'{num1 - num2}')
    elif operator == '*':
        print(f'{num1 * num2}')
    elif operator == '/':
        print(f'{num1 / num2}')
    else:
        print('算不出来')


calculator()

6. 已知列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标

points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]
# 1）获取列表中y坐标最大的点
# 2）获取列表中x坐标最小的点
# 3）获取列表中距离原点最远的点
# 4）将点按照点到x轴的距离大小从大到小排序