day10 函数的参数与返回值；变量的作用域

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

根据实参的提供，不同的实参分为位置参数和关键字参数

"""
1）位置参数：调用函数的时候让实参和形参一一对应
2）关键字参数： 调用函数的时候以‘形参名=值’的形式确定形参对应的实参
3）位置参数和关键字参数混用：位置参数必须在关键字参数前面，同时必须保证每个参数都会有一次赋值
“”"

位置参数

def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')


func1(10, 20, 30)   # x:10, y:20, z:30
func1(22, 33, 11)   # x:22, y:33, z:11

关键字参数

func1(x=11, y=22, z=33)     # x:11, y:22, z:33
func1(y=11, z=22, x=33)     # x:33, y:11, z:22

混合用

func1(10, 20, z=30)     # x:10, y:20, z:30
func1(11, z=22, y=33)   # x:11, y:33, z:22

2.参数默认值

定义函数的时候可以直接在形参后面用=赋值符号给形参赋默认值

有默认值的参数在调用的时候可以不用传参

如果有的参数有默认值，有的没有默认值，那么有默认值的参数必须放在没有默认值参数的后面

def func2(x=10, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


func2()     # x:10, y:20, z:30
func2(100)  # x:100, y:20, z:30
func2(z=300)    # x:10, y:20, z:300

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


func3(3)    # x:10, y:20, z:3
func3(z=33)     # x:10, y:20, z:33

3.参数类型说明

无默认值参数的类型说明 - :类型名

有默认值的参数，默认值的类型就是参数对应的类型

def func4(x:str, y=''):
    x.split('\n')
    y.replace('you', 'me')

4.不定长参数

"""
1）带*的不定长参数：在某个形参前加*，那么这个形参就是一个不定长参数，它可以接受任意多个实参；
带*的参数本质就是一个元组，对应的实参是元组中的元素
注意：带*的不定长参数对应的实参必须用位置参数传参
2)带**的不定长参数：在某个形参前加**，那么这个形参就是一个不定长参数，它可以接受任意多个实参
带**的不定长参数本质就是一个字典，对应的关键字参数就是字典中的键值对
注意：带**的不定长参数对应的实参必须使用关键字参数传参
“”"

def func5(*x):
    print(x)


func5()     # ()
func5(10)   # (10,)
func5(10, 20)   # (10, 20)
func5(1, 2, 3, 4, 5)    # (1, 2, 3, 4, 5)

1）如果定长参数在不定长参数前面，定长和不定长都适用位置参数传参

def func6(x, *y):
    print(f'{x}, {y}')


func6(10, 1, 2, 3, 4)   # 10, (1, 2, 3, 4)

def func7(*nums, char):
    print(f'nums:{nums},char:{char}')


func7(10, 20, char='*')     # nums:(10, 20),char:*

2)定长参数在不定长参数后面，不定长参数后面的定长参数必须用关键字传参

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


func8(a=10, b=20, c=30)     # a:10,b:20,c:30

3)**的使用

def func9(**x):
    print(x)


func9()     # {}
func9(x=10)     # {'x': 10}
func9(a=10, b=20, c=30)     # {'a': 10, 'b': 20, 'c': 30}

4）定长参数在**不定长参数前，定长参数既可以用位置参数也可以用关键字参数

def func10(x, **y):
    print(f'x:{x}, y:{y}')


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

5)定长参数不能放在**不定长参数后面

def func11(**x, y):   # 会报错

6）带*的不定长参数和带**的不定长参数可以一起用，带*的必须放在带**的前面

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


func11()    # () {}
func11(10)  # (10,) {}
func11(10, 20, 30)  # (10, 20, 30) {}
func11(a=1, b=2)    # () {'a': 1, 'b': 2}
func11(1, 11, a=1, b=2)     # (1, 11) {'a': 1, 'b': 2}

返回值

1.返回值是什么：

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

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

在函数体中用return关键字来返回返回值（一个函数只有一个返回值）
什么时候需要返回值：如果函数的功能产生了新的数据，将新的数据返回。

3.怎么获取函数返回值 - 获取函数调用表达式的值就是获取函数返回值

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

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


print(sum2(1, 2))   # 3

4.函数调用过程

"""
第一步：回到函数定义的位置
第二步：传参（用实参给形参赋值，保证每个参数都有值）
第三步：执行函数体
第四步：执行完函数体的时候确定函数返回值
（看执行函数体的时候有没有遇到return，如果遇到return，return后面的值是什么，函数返回值就是什么，
并且在遇到return的时候函数直接结束。如果没有遇到return，函数返回值就是None）
第五步：回到函数调用的位置（这个时候函数调用表达式的值才是函数的返回值）
“”"

python的函数只有一个返回值

def func3():
    return 10, 20

print(func3())  # (10, 20)

练习1：写一个函数通过指定方法来计算多个结果
operation(’+’, 10, 20, 30) -> 求： 10+20+30
operation(’’, 3, 4， 5, 6) -> 求 3456
operation(’-’, 10, 3, 4) -> 求： 10-3-4
operation(’/’, 19, 2) -> 求 19/2

def operation(str1, *nums):
    if len(nums) > 1 and str1 in ('+', '-', '*', '/'):
        result = 0
        if str1 == '+':
            for i in nums:
                result += i
            return result

        if str1 == '-':
            for i in nums:
                result -= i
            return result

        if str1 == '*':
            result = 1
            for i in nums:
                result *= i
            return result

        if str1 == '/':
            result = nums[0]
            for i in nums[1:]:
                result /= i
            return result
    else:
        return None


print(operation('+', 10, 20))   # 30
print(operation('-', 10, 20))   # -30
print(operation('*', 10, 20))   # 200
print(operation('/', 100, 20))  # 5.0
print(operation('+'))   # None

练习2：判断奇偶性

def odevity(num:int):
    if num % 2:
        return '奇数'
    return '偶数'

1.变量的作用域 - 已经定义过的变量能使用的范围

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

1)全局变量

"""
没有定义在函数里面或者类里面的变量，就是全局变量
全局变量的作用域：从定义开始到程序结束的任何位置都可以使用
“”"

a = 10
for i in range(5):
    b = 20
# a,i,b都是全局变量
print(a)    # 10
print(i)    # 4
print(b)    # 20

2)局部变量

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

def func2(c=3):
    d = 100
    print(f'c:{c},d:{d}')


# c和d都是局部变量
# print(c,d)    # 会报错，变量c与d未定义
func2()     # c:3,d:100

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

"""
调用函数的时候，系统会自动在栈区间为这个函数创建一个临时栈区间，用来保存在函数中产生的数据（局部变量）
当函数调用结束的时候，临时栈区间会自动释放（释放之间会将返回值传递到临时栈区间的外部）。
“”"

3.global

"""
在函数中修改一个全局变量的值或者在函数中定义一个全局变量
用法：
global 变量名
使用变量
“”"

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

    global n
    n = 'abc'


func3()     # 函数内部num:40
print('函数外部num:', num)   # 函数外部num 10
print('函数外部m:', m)  # 函数外部m: 200
print('函数外部n:', n)  # 函数外部n: abc

作业

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

例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14


def square_sum(nums:int):
    count = 0
    while 1:
        if nums > 9:
            count = (nums % 10)**2
            nums //= 10
        else:
            count += nums ** 2
            return count
            

# 方法2
def square_sum(nums:int):
	if nums < 0:
		nums *= -1
    sum1 = 0
    for i in str(nums):
        sum1 += int(i) ** 2
    return sum1
            

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

例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-234


def abs_max(list1):
    max_num = max(abs(i) for i in nums)
    num1 = [i for i in list1 if abs(i) == max_num]
    return num1

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

def join_(seq, str1):
    new_str = ''
    for i in seq:
        if type(i) != str:
            new_str += str(i) + str1
        else:
            new_str += i + str1
    return new_str[:-len(str1)]

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

def extend_(list1: list, seq):
    for i in seq:
        list1.append(i)

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

   执行过程1：
   计算器：
   >10
   >+
   >20
   =30
   
   执行过程1：
   计算器：
   >10
   >x
   >20
   =200
   

def counter():
    print('计算器：')
    num1 = float(input('>'))
    operator = input('>')
    num2 = float(input('>'))
    if operator in ('+', '-', '*', '/'):
        result = 0
        if operator == '+':
            return print(f'={num1 + num2}')
        if operator == '-':
            return print(f'={num1 - num2}')
        if operator == '*':
            return print(f'={num1 * num2}')
        if operator == '/':
            return print(f'={num1 / num2}')

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

   points = [(10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)]
   
   # 1）获取列表中y坐标最大的点
   def y_max(list1):
       list2 = []
    max_y = []
       for i in list1:
        list2.append(abs(i[1]))
       max_num = max(list2)
    for i in list1:
           if max_num == abs(i[1]):
            max_y.append(i)
       return max_y
   
   2）获取列表中x坐标最小的点
   def x_min(list1):
       list2 = []
       min_x = []
       for i in list1:
           list2.append(abs(i[0]))
       min_num = min(list2)
       for i in list1:
           if min_num == abs(i[0]):
               min_x.append(i)
       return min_x
   
   3）获取列表中距离原点最远的点
   def dist_max(list1):
       dist = []
       max_dist = []
       for i in list1:
           x, y = i
           dist.append(abs(x)+abs(y))
       max_num = max(dist)
       for i in list1:
           x, y = i
           if max_num == abs(x) + abs(y):
               max_dist.append(i)
       return max_dist
   
   4）将点按照点到x轴的距离大小从大到小排序
   def poit_dict(list1):
       if not points:
           return None
       new_points = []
       list1 = sorted({abs(x[-1]) for x in points}, reverse=True)
       for value in list1:
           new_points.extend([x for x in points if x[-1] in [value, -value]])
       return new_points
   
   

   1）获取列表中y坐标最大的点

   2）获取列表中x坐标最小的点

   3）获取列表中距离原点最远的点

   4）将点按照点到x轴的距离大小从大到小排序