day-10函数进阶

函数进阶

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

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

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

#位置参数
func1(10, 20, 50)

#关键字参数
func1(y=10, z=20, x=30)
func1(z=3, x=98, y=24)  # 位置还是形参位置  x y z

#混用
func1(10, 20, z=50)
func1(50, z=80, y=15

# func1(x=50, 50, z=30)  # 报错 SyntaxError
"""

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=30):  # 没有默认值的在前面，有默认值的在后面
    print(f'x:{x}, y:{y}, z{z}')

func3(500)  # x:10, y:30, z500
func3(z=4000)  # x:10, y:30, z4000

3. 参数类型说明

"""
1)带*的不定参数：在某个形参前加*，那么这个形参就是一个不定长参数，它可以接收任意多个实参
               带*的参数本质就是一个元组，对应的实参是元组中的元素
    注意：带*的不定长参数对应的实参必须用位置参数传参

2)带**的不定长参数： 在某个形参前加**，那么这个形参就一个不定长参数，它可以接收任意多个实参
                   带**的参数本质就是一个字典，对应的关键字参数就是字典中的键值对
     注意: **的不定长参数对应的实参必须使用关键字参数传参
"""

def func5(*x):
    print(x)


func5()
func5(50)
func5(10, 60)

​ 分类：

# 1. 定长参数在*的不定长参数钱，定长和不定长都适用位置参数传参

def func6(char, x, *nums):
    print(f'char:{char},nums:{nums}')
    
unc6('+', 'a')
func6('x', 50, 14, 30)

# 2. 定长在*的不定长参数，*后面的定长参数必须是用关键字参数传参
def func7(*nums, str1):
    print(f'nums:{nums}, str1:{str1}')
    
func7(10, 50, str1='*')

def func8(*, a, b, c):  # 后面adc都必须用关键字传参
    print(f'a:{a}, b；{b}, c:{c}')

print(func8(a=10, b=20, c=30))

# 3. **的使用   # 必须使用关键字传参
def func9(**x):  # 是字典
    print(x)

func9()  # {}  # 是字典
func9(x=10)  # {'x': 10}
func9(a=9, b=6)  # {'a': 9, 'b': 6}
func9(m=1, n=10, a=50, b=65)  # {'m': 1, 'n': 10, 'a': 50, 'b': 65}

# 4. 定长参数在**的不定长前，定长既可以用位置参数也可以用关键字参数
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}

# 5. 定长参数不能放在**对应不定长参数后面

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

func11()   # () {}
func11(10)  # (10,) {}
func11(10, 2, 98)  # (10, 2, 98) {}
func11(a=2)        # () {'a': 2}
func11(a=5, b=64)  # () {'a': 5, 'b': 64}
func11(1, 234, a=32)  # (1, 234) {'a': 32}

2. 函数的返回值

   ​ 1.返回值
   返回值的作用： 就将函数内部的数据传递到函数外部

   ​ 2.怎么确定函数返回值 - 怎么将函数内部的数据传递到外部
   在函数体中用 return 关键字来返回返回值 (一个函数只有一个返回值)
   什么时候需要返回值：如果函数的功能产生了新的数据，将新的数据返回。

   ​ 3.怎么回去函数返回值
   获取函数调用表达式的值，就是获取函数返回值什么是函数调用表达式 - 调用函数语句
   函数调用表达式的值就是函数返回值，函数返回值能做的事情，函数调用表达式都可以做

def sum2(num1,num2):
    # num1 = 10, num2 = 20
    return num1 + num2    # return =30

result = sum2(10, 20)
print(result)

def func1():
    return 100

print(100)
print(func1())

a = 100
b = func1()
print(a, b)  # 100 100

a = 100 + 200
b = func1() + 200

list1 = [100, func1()]
print(list1)

dict1 = {'a': 100, 'b': func1()}

def func2():
    return [10, 20]

print([10, 20][-1])   # 20
print(func2()[-1])    # 20

list1 = [10, 20]
list2 = func2()
list1.append(100)
list2.append(100)
print(list1, list2)   # [10, 20, 100] [10, 20, 100]

str1 = '100, 200'
for x in str1:
    if x < '100':
        print(func2(), x)

4. 函数调用的过程

"""
第一步：回到函数定义的位置
第二步：传参(用实参给形参赋值，这个时候要保证每个参数都有值)
第三步：执行函数体
第四步：执行完函数体的时候确定函数返回值
       (看执行函数体的时候有没有遇到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(add: str, *nums):
    if not nums or add not in ('+', '-', '*', '/'):
        return None
    if add == '+'
    	sum1 = 0
        for x in nums:
            sum1 += x
        return sum1
    
    if add == '*'
    	sum1 == 0
        for x in nums:
            sum1 *= x
        return sum1
    
	if add == '-':
        sum1 = nums[0]
        for x in nums[1:]:
            sum1 -= x 
        return sum1
    
    if add == '/'：
    	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))

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

3. 变量的作用域

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

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

​ 2.全局变量

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

# a、b和x都是全局变量
a = 10
for x in range(5):
    b = 20
    print()

print('循环外:', x )

def func1():
    print(f'函数里面a:{a}, b:{b}, x:{x}')

​ 3.局部变量

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


# c和d都是局部变量
def func2(c=3):
    d = 100
    print(f'函数内部c:{c}, d:{d}')



func2()
# print(f'函数外部c:{c}, d:{d}')

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

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

​ 5.global

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

global 变量名
使用变量
"""

num = 30
m = 100

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

    global n
    n = 'abc'
    
func3()
print(f'函数外部num:{num}')
print(f'函数外部m:{m}')
print(f'函数外部n:{n}')

作业

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

# 例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14
def squares():
    """
    计算一个整数的各位数的平方和
    :return: 返回值是 num2
    """
    num1 = int(input('输入一个数：'))
    num2 = 0
    for x in str(num1):
        num2 += int(x) ** 2
    return num2

print(squares())

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

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

def maximum(nums1):
    """
    求一个数字列表中绝对值最大的元素
    :param nums1: 求绝对值的列表
    :return: 绝对值最大的元素
    """
    nums2 = nums1[0]
    for x in nums1[1:]:
        if math.fabs(x) > math.fabs(nums2):
            nums2 = x
    return nums2


nums1 = [-23, 100, 89, -56, -234, 123]
print(maximum(nums1))

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

def  merge(str1, list2):    
    list3 = ''
     """
    将指定序列中的元素通过指定字符串合并成一个新的字符串
    :param str1: 需要拼接的序列
    :param list2:  拼接字符串
    :return: 新字符串
    """
    for x in list2[:-1]:
        list3 += str(x) + str1
        print(list3)
    return list3 + list2[-1]

list1 = 'acd'
list2 = '='
print(merge(list2, list1))

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

def extend(list1:list, list2):
    """
    将指定序列中的元素全部添加到指定列表中
    :param list1: 指定列表1
    :param list2: 指定序列2
    :return: None
    """
    for x in list2:
        list1.append(x)


list1 = ['a', 's']
list2 = [12, 'asd']
extend(list1, list2)
print(list1)

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

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

def computation(operator, *nums):
    if not nums or operator not in ('+', '-', '*', '/'):
        return None
    if operator == '+':
        num1 = 0
        for x in nums:
            num1 += x
        return num1

    if operator == '*':
        num1 = 0
        for x in nums:
            num1 *= x
        return num1

    if operator == '-':
        num1 = nums[0]
        for x in nums[1:]:
            num1 -= x
        return num1

    if operator == '/':
        num1 = nums[0]
        for x in nums[1:]:
            num1 /= x
        return num1

print(computation('+', 50, 50,30))
print(computation('-', 98, 12,46))
print(computation('*', 1, 34, 12))
print(computation('/', 45, 2, 4))

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

points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]